diff --git a/core/modules/jsonld/lib/Drupal/jsonld/JsonldBundle.php b/core/modules/jsonld/lib/Drupal/jsonld/JsonldBundle.php
index 3024883..b62328f 100644
--- a/core/modules/jsonld/lib/Drupal/jsonld/JsonldBundle.php
+++ b/core/modules/jsonld/lib/Drupal/jsonld/JsonldBundle.php
@@ -51,6 +51,7 @@ public function build(ContainerBuilder $container) {
         $container->register("serializer.normalizer.{$supported_class}.{$format}", $normalizer_class)
           ->addArgument(new Reference('rdf.site_schema_manager'))
           ->addArgument(new Reference('rdf.mapping_manager'))
+          ->addMethodCall('setEntityReferenceHandlerPluginManager', array(new Reference('plugin.manager.serialization.entityreference_handler')))
           ->addTag('normalizer', array('priority' => $priority));
       }
     }
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityNormalizer.php b/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityNormalizer.php
index ab662b3..11004af 100644
--- a/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityNormalizer.php
+++ b/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityNormalizer.php
@@ -8,6 +8,7 @@
 namespace Drupal\jsonld;
 
 use Drupal\jsonld\JsonldNormalizerBase;
+use Drupal\serialization\Plugin\Type\EntityReferenceHandlerPluginManager;
 use Drupal\rdf\RdfMappingException;
 use Symfony\Component\Serializer\Exception\UnexpectedValueException;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
@@ -112,7 +113,16 @@ public function denormalize($data, $class, $format = null, array $context = arra
       // The vnd.drupal.ld+json mime type will always use language keys, per
       // http://drupal.org/node/1838700.
       foreach ($incomingFieldValues as $langcode => $incomingFieldItems) {
-        $fieldValue = $this->serializer->denormalize($incomingFieldItems, $fieldItemClass, $format);
+        $field_definition = $entity->getPropertyDefinition($fieldName);
+        if ($field_definition['type'] == 'entity_reference_field') {
+          $options = array(
+            'field' => $field_definition,
+            'field_name' => $fieldName,
+            'format' => $format,
+          );
+          $context['entityreference_handler'] = $this->entityReferenceHandlerPluginManager->getInstance($options);
+        }
+        $fieldValue = $this->serializer->denormalize($incomingFieldItems, $fieldItemClass, $format, $context);
         $entity->getTranslation($langcode)
           ->set($fieldName, $fieldValue);
       }
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityReferenceNormalizer.php b/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityReferenceNormalizer.php
index f57066d..e91879f 100644
--- a/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityReferenceNormalizer.php
+++ b/core/modules/jsonld/lib/Drupal/jsonld/JsonldEntityReferenceNormalizer.php
@@ -2,7 +2,7 @@
 
 /**
  * @file
- * Definition of Drupal\jsonld\JsonldEntityReferenceNormalizer.
+ * Contains \Drupal\jsonld\JsonldEntityReferenceNormalizer.
  */
 
 namespace Drupal\jsonld;
@@ -14,11 +14,19 @@
 use ReflectionClass;
 use Symfony\Component\Serializer\Exception\RuntimeException;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Drupal\serialization\Plugin\serialization\entityreference_handler\UuidReferenceInterface;
 
 /**
  * Converts an EntityReferenceItem to a JSON-LD array structure.
  */
-class JsonldEntityReferenceNormalizer extends JsonldNormalizerBase implements DenormalizerInterface {
+class JsonldEntityReferenceNormalizer extends JsonldNormalizerBase implements DenormalizerInterface, UuidReferenceInterface {
+
+  /**
+   * The incoming data.
+   *
+   * @var array
+   */
+  protected $data;
 
   /**
    * The interface or class that this Normalizer supports.
@@ -31,23 +39,36 @@ class JsonldEntityReferenceNormalizer extends JsonldNormalizerBase implements De
    * Implements \Symfony\Component\Serializer\Normalizer\NormalizerInterface::normalize()
    */
   public function normalize($object, $format = NULL, array $context = array()) {
-    // @todo If an $options parameter is added to the serialize signature, as
+    $return = array();
+    // @todo Since the context parameter was added to Serilizer's interface, as
     // requested in https://github.com/symfony/symfony/pull/4938, then instead
     // of creating the array of properties, we could simply call normalize and
     // pass in the referenced entity with a flag that ensures it is rendered as
     // a node reference and not a node definition.
     $entity_wrapper = new JsonldEntityWrapper($object->entity, $format, $this->serializer, $this->siteSchemaManager);
-    return array(
-      '@id' => $entity_wrapper->getId(),
-    );
+    $return['@id'] = $entity_wrapper->getId();
+
+    // @todo Remove this if statement once all entities are EntityNG.
+    if ($object instanceof \Drupal\Core\Entity\EntityNG) {
+      $properties = $entity_wrapper->getProperties();
+      $return['uuid'] = $properties['uuid'];
+    }
+
+    return $return;
   }
 
   /**
    * Implements \Symfony\Component\Serializer\Normalizer\DenormalizerInterface::denormalize()
    */
-  public function denormalize($data, $class, $format = null, array $context = array()) {
-    // @todo Support denormalization for Entity Reference.
-    return array();
+  public function denormalize($data, $class, $format = NULL, array $context = array()) {
+    $return = array();
+    $entityreference_handler = $context['entityreference_handler'];
+
+    foreach ($data as $node) {
+      $this->data = $node;
+      $return[]['target_id'] = $entityreference_handler->getEntityId($this);
+    }
+    return $return;
   }
 
   /**
@@ -58,4 +79,17 @@ public function supportsDenormalization($data, $type, $format = NULL) {
     return in_array($format, static::$format) && ($reflection->getName() == static::$supportedInterfaceOrClass || $reflection->isSubclassOf(static::$supportedInterfaceOrClass));
   }
 
+  /**
+   * Implements \Drupal\serialization\ReferenceHandler\UuidExtractorInterface::getUuid().
+   */
+  public function getUuid() {
+    if (isset($this->data['uuid'])) {
+      $uuid = $this->data['uuid'];
+      while (is_array($uuid)) {
+        $uuid = reset($uuid);
+      }
+      return $uuid;
+    }
+  }
+
 }
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/JsonldNormalizerBase.php b/core/modules/jsonld/lib/Drupal/jsonld/JsonldNormalizerBase.php
index e898da8..b5ba7ed 100644
--- a/core/modules/jsonld/lib/Drupal/jsonld/JsonldNormalizerBase.php
+++ b/core/modules/jsonld/lib/Drupal/jsonld/JsonldNormalizerBase.php
@@ -8,22 +8,14 @@
 namespace Drupal\jsonld;
 
 use ReflectionClass;
+use Drupal\serialization\Normalizer\NormalizerBase;
 use Drupal\rdf\RdfMappingManager;
 use Drupal\rdf\SiteSchema\SiteSchemaManager;
-use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
-use Symfony\Component\Serializer\Normalizer\SerializerAwareNormalizer;
 
 /**
  * Provide a base class for JSON-LD Normalizers.
  */
-abstract class JsonldNormalizerBase extends SerializerAwareNormalizer implements NormalizerInterface {
-
-  /**
-   * The interface or class that this Normalizer supports.
-   *
-   * @var string
-   */
-  protected static $supportedInterfaceOrClass;
+abstract class JsonldNormalizerBase extends NormalizerBase {
 
   /**
    * The formats that this Normalizer supports.
@@ -60,7 +52,7 @@ public function __construct(SiteSchemaManager $site_schema_manager, RdfMappingMa
   }
 
   /**
-   * Implements \Symfony\Component\Serializer\Normalizer\NormalizerInterface::normalize()
+   * Overrides \Drupal\Core\Serialization\NormalizerBase::supportsNormalization()
    */
   public function supportsNormalization($data, $format = NULL) {
     return is_object($data) && in_array($format, static::$format) && ($data instanceof static::$supportedInterfaceOrClass);
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/Tests/DenormalizeTest.php b/core/modules/jsonld/lib/Drupal/jsonld/Tests/DenormalizeTest.php
new file mode 100644
index 0000000..08130d4
--- /dev/null
+++ b/core/modules/jsonld/lib/Drupal/jsonld/Tests/DenormalizeTest.php
@@ -0,0 +1,203 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\jsonld\Tests\DenormalizeTest.
+ */
+
+namespace Drupal\jsonld\Tests;
+
+use Drupal\rdf\SiteSchema\SiteSchema;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
+
+class DenormalizeTest extends NormalizerTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('entity_reference');
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Denormalize Test',
+      'description' => 'Test that entities can be denormalized from JSON-LD.',
+      'group' => 'JSON-LD',
+    );
+  }
+
+  /**
+   * Overrides NormalizerTestBase::setUp().
+   */
+  public function setUp() {
+    parent::setUp();
+    $schema = new SiteSchema(SiteSchema::CONTENT_DEPLOYMENT);
+    $this->bundle_uri = $schema->bundle('entity_test', 'entity_test')->getUri();
+  }
+
+  /**
+   * Test that fields with literal values can be denormalized.
+   */
+  function testBasicDenormalize() {
+    $incoming_data = array(
+      '@type' => $this->bundle_uri,
+      'name' => array(
+        'en' => array(
+          array(
+            'value' => $this->randomName(),
+          ),
+        ),
+        'de' => array(
+          array(
+            'value' => $this->randomName(),
+          ),
+        ),
+      ),
+      'field_test_text' => array(
+        'und' => array(
+          array(
+            'value' => $this->randomName(),
+            'format' => 'full_html',
+          ),
+        ),
+      ),
+    );
+
+    // Test valid request.
+    $serializer = $this->container->get('serializer');
+    $entity = $serializer->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', $this->format);
+    $this->assertEqual('entity_test', $entity->bundle(), "Denormalize creates entity with correct bundle.");
+    $this->assertEqual($incoming_data['name']['en'], $entity->get('name')->getValue(), "Translatable field denormalized correctly in default language.");
+    $this->assertEqual($incoming_data['name']['de'], $entity->getTranslation('de')->get('name')->getValue(), "Translatable field denormalized correctly in translation language.");
+    $this->assertEqual($incoming_data['field_test_text']['und'], $entity->get('field_test_text')->getValue(), "Untranslatable field denormalized correctly.");
+
+    // Test request without @type.
+    unset($incoming_data['@type']);
+    try {
+      $serializer->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', $this->format);
+      $this->fail('Trying to denormalize entity data without @type results in exception.');
+    }
+    catch (UnexpectedValueException $e) {
+      $this->pass('Trying to denormalize entity data without @type results in exception.');
+    }
+
+    // Test request with @type that has no valid mapping.
+    $incoming_data['@type'] = 'http://failing-uri.com/type';
+    try {
+      $serializer->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', $this->format);
+      $this->fail('Trying to denormalize entity data with unrecognized @type results in exception.');
+    }
+    catch (UnexpectedValueException $e) {
+      $this->pass('Trying to denormalize entity data with unrecognized @type results in exception.');
+    }
+  }
+
+  /**
+   * Test that fields with resource values can be denormalized.
+   */
+  function testEntityReferenceDenormalize() {
+    // Configure the entity reference handlers.
+    $handler_settings = entity_create('entityreference_handler_settings', array('format' => $this->format));
+    $handler_settings->setHandler('user_id', 'null_value');
+    $handler_settings->save();
+
+    $incoming_data = array(
+      '@type' => $this->bundle_uri,
+      'name' => array(
+        'en' => array(
+          array(
+            'value' => $this->randomName(),
+          ),
+        ),
+      ),
+      'user_id' => array(
+        'und' => array(
+          array(
+            '@id' => 'http://example.org/user/foo',
+          ),
+        ),
+      ),
+    );
+
+    // Deserialize the data.
+    $serializer = $this->container->get('serializer');
+    $entity = $serializer->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', $this->format);
+
+    // Test the null value handler.
+    $this->assertEqual(array(NULL), $entity->get('user_id')->getValue(), 'The null value entity reference handler works.');
+  }
+
+  /**
+   * Test that fields with resource values can be denormalized.
+   *
+   * @todo Move this to serialization tests once we have a JSON deserializer.
+   */
+  function testUuidEntityReferenceHandler() {
+    // Create the test field.
+    $field = array(
+      'settings' => array(
+        'target_type' => 'entity_test',
+      ),
+      'field_name' => 'field_test_entity_reference',
+      'type' => 'entity_reference',
+    );
+    field_create_field($field);
+
+    // Create the test field instance.
+    $instance = array(
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test_entity_reference',
+      'bundle' => 'entity_test',
+    );
+    field_create_instance($instance);
+
+    // Configure the entity reference handler.
+    $handler_settings = entity_create('entityreference_handler_settings', array('format' => $this->format));
+    // The uuid_key is set to 'guid' to demonstrate how entity reference
+    // handler configuration works.
+    $handler_settings->setHandler('field_test_entity_reference', 'uuid');
+    $handler_settings->save();
+
+    // Create an entity to get the UUID from.
+    $entity = entity_create('entity_test', array('type' => 'entity_test'));
+    $entity->set('name', 'foobar');
+    $entity->set('field_test_entity_reference', NULL);
+    $entity->save();
+
+    $incoming_data = array(
+      '@type' => $this->bundle_uri,
+      'name' => array(
+        'en' => array(
+          array(
+            'value' => $this->randomName(),
+          ),
+        ),
+      ),
+      'field_test_entity_reference' => array(
+        'und' => array(
+          array(
+            '@id' => 'http://example.org/bar',
+            'uuid' => array(
+              'und' => array(
+                array(
+                  'value' => $entity->uuid(),
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+
+    // Deserialize the data.
+    $serializer = $this->container->get('serializer');
+    $deserialized_entity = $serializer->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', $this->format);
+
+    // Test that the correct value was set for the entity reference field.
+    $deserialized_field_value = $deserialized_entity->get('field_test_entity_reference')->getValue();
+    $expected_field_value = array(array('target_id' => $entity->id()));
+    $this->assertEqual($deserialized_field_value, $expected_field_value, 'Entity reference field is properly set based on UUID.');
+
+  }
+}
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/Tests/JsonldTestSetupHelper.php b/core/modules/jsonld/lib/Drupal/jsonld/Tests/JsonldTestSetupHelper.php
index d0eb0c3..8ae5a3b 100644
--- a/core/modules/jsonld/lib/Drupal/jsonld/Tests/JsonldTestSetupHelper.php
+++ b/core/modules/jsonld/lib/Drupal/jsonld/Tests/JsonldTestSetupHelper.php
@@ -8,6 +8,7 @@
 namespace Drupal\jsonld\Tests;
 
 use Drupal\Core\Cache\DatabaseBackend;
+use Drupal\Core\Language\Language;
 use Drupal\jsonld\JsonldEncoder;
 use Drupal\jsonld\JsonldEntityNormalizer;
 use Drupal\jsonld\JsonldEntityReferenceNormalizer;
@@ -15,11 +16,14 @@
 use Drupal\rdf\RdfMappingManager;
 use Drupal\rdf\EventSubscriber\MappingSubscriber;
 use Drupal\rdf\SiteSchema\SiteSchemaManager;
+use Drupal\serialization\Plugin\Type\EntityReferenceHandlerPluginManager;
 use Symfony\Component\EventDispatcher\EventDispatcher;
 use Symfony\Component\Serializer\Serializer;
 
 /**
  * Constructs services for JSON-LD tests.
+ *
+ * @todo Remove this once REST tests use DrupalUnitTestBase.
  */
 class JsonldTestSetupHelper {
 
@@ -45,6 +49,13 @@ class JsonldTestSetupHelper {
   protected $normalizers;
 
   /**
+   * The Serializer.
+   *
+   * @var \Symfony\Component\Serializer\Serializer
+   */
+  protected $serializer;
+
+  /**
    * Constructor.
    */
   public function __construct() {
@@ -60,8 +71,10 @@ public function __construct() {
       'field_item' => new JsonldFieldItemNormalizer($this->siteSchemaManager, $this->rdfMappingManager),
       'entity' => new JsonldEntityNormalizer($this->siteSchemaManager, $this->rdfMappingManager),
     );
-    $serializer = new Serializer($this->normalizers, array(new JsonldEncoder()));
-    $this->normalizers['entity']->setSerializer($serializer);
+    $this->serializer = new Serializer($this->normalizers, array(new JsonldEncoder()));
+    $this->normalizers['entity']->setSerializer($this->serializer);
+    $this->normalizers['entity']->setEntityReferenceHandlerPluginManager(new EntityReferenceHandlerPluginManager());
+
   }
 
   /**
@@ -75,6 +88,16 @@ public function getNormalizers() {
   }
 
   /**
+   * Get Serializer.
+   *
+   * @return \Symfony\Component\Serializer\Serializer
+   *   The serializer.
+   */
+  public function getSerializer() {
+    return $this->serializer;
+  }
+
+  /**
    * Get the SiteSchemaManager object.
    *
    * @return \Drupal\rdf\SiteSchema\SiteSchemaManager
@@ -93,4 +116,16 @@ public function getSiteSchemaManager() {
   public function getRdfMappingManager() {
     return $this->rdfMappingManager;
   }
+
+  /**
+   * Create a second language to use when testing multilingual values.
+   */
+  public function saveSecondLanguage() {
+    // Add German as a language.
+    $language = new Language(array(
+      'langcode' => 'de',
+      'name' => 'Deutsch',
+    ));
+    language_save($language);
+  }
 }
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizeDenormalizeTest.php b/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizeDenormalizeTest.php
deleted file mode 100644
index a9e057d..0000000
--- a/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizeDenormalizeTest.php
+++ /dev/null
@@ -1,213 +0,0 @@
-<?php
-
-/**
- * @file
- * Contains Drupal\jsonld\Tests\NormalizeDenormalizeTest.
- */
-
-namespace Drupal\jsonld\Tests;
-
-use Drupal\Core\Language\Language;
-use Drupal\rdf\SiteSchema\SiteSchema;
-use Drupal\simpletest\WebTestBase;
-use Drupal\Core\DependencyInjection\ContainerBuilder;
-use Symfony\Component\Serializer\Exception\UnexpectedValueException;
-
-/**
- * Test the vendor specific JSON-LD normalizer.
- *
- * This is implemented as a WebTest because it requires use of the Entity API.
- */
-class NormalizeDenormalizeTest extends WebTestBase {
-
-  /**
-   * Modules to enable.
-   *
-   * @var array
-   */
-  public static $modules = array('entity_test', 'jsonld', 'language', 'rdf');
-
-  /**
-   * The format being tested.
-   */
-  protected static $format = 'drupal_jsonld';
-
-  /**
-   * The Normalizers to be tested.
-   */
-  protected $normalizers;
-
-  public static function getInfo() {
-    return array(
-      'name' => 'Normalize/Denormalize Test',
-      'description' => "Test that entities can be normalized/denormalized in JSON-LD.",
-      'group' => 'JSON-LD',
-    );
-  }
-
-  /**
-   * Add the normalizer to be tested.
-   */
-  function setUp() {
-    parent::setUp();
-
-    $setup_helper = new JsonldTestSetupHelper();
-    $this->normalizers = $setup_helper->getNormalizers();
-
-    // Add German as a language.
-    $language = new Language(array(
-      'langcode' => 'de',
-      'name' => 'Deutsch',
-    ));
-    language_save($language);
-  }
-
-  /**
-   * Tests the normalize function.
-   */
-  public function testNormalize() {
-    // Create a German entity.
-    $values = array(
-      'langcode' => 'de',
-      'name' => $this->randomName(),
-      'user_id' => $GLOBALS['user']->uid,
-      'field_test_text' => array(
-        'value' => $this->randomName(),
-        'format' => 'full_html',
-      ),
-    );
-    // Array of translated values.
-    $translationValues = array(
-      'name' => $this->randomName(),
-    );
-
-    $entity = entity_create('entity_test', $values);
-    $entity->save();
-    // Add an English value for name property.
-    $entity->getTranslation('en')->set('name', array(0 => array('value' => $translationValues['name'])));
-
-    $expectedArray = array(
-      '@id' => $this->getEntityId($entity),
-      'uuid' => array(
-        'und' => array(
-          array(
-            'value' => $entity->uuid(),
-          ),
-        ),
-      ),
-      'user_id' => array(
-        'de' => array(
-          array(
-            '@id' => url('user/' . $values['user_id'], array('absolute' => TRUE)),
-          ),
-        ),
-      ),
-      'name' => array(
-        'de' => array(
-          array(
-            'value' => $values['name'],
-          ),
-        ),
-        'en' => array(
-          array(
-            'value' => $translationValues['name'],
-          ),
-        ),
-      ),
-      'field_test_text' => array(
-        'und' => array(
-          array(
-            'value' => $values['field_test_text']['value'],
-            'format' => $values['field_test_text']['format'],
-          ),
-        ),
-      ),
-    );
-
-    $normalized = $this->normalizers['entity']->normalize($entity, static::$format);
-    // Test ordering. The @context and @id properties should always be first.
-    $keys = array_keys($normalized);
-    $this->assertEqual($keys[0], '@id', '@id and @context attributes placed correctly.');
-    // Test @id value.
-    $this->assertEqual($normalized['@id'], $expectedArray['@id'], '@id uses correct value.');
-    // Test non-translatable field.
-    $this->assertEqual($normalized['uuid'], $expectedArray['uuid'], 'Non-translatable fields are nested correctly.');
-    // Test single-language translatable.
-    $this->assertEqual($normalized['user_id'], $expectedArray['user_id'], 'Translatable field with single language value is nested correctly.');
-    // Test multi-language translatable.
-    $this->assertEqual($normalized['name'], $expectedArray['name'], 'Translatable field with multiple language values is nested correctly.');
-    // Test multi-property untranslatable field.
-    $this->assertEqual($normalized['field_test_text'], $expectedArray['field_test_text'], 'Field with properties is nested correctly.');
-  }
-
-  function testDenormalize() {
-    $schema = new SiteSchema(SiteSchema::CONTENT_DEPLOYMENT);
-    $bundle_uri = $schema->bundle('entity_test', 'entity_test')->getUri();
-    $incoming_data = array(
-      '@type' => $bundle_uri,
-      'name' => array(
-        'en' => array(
-          array(
-            'value' => $this->randomName(),
-          ),
-        ),
-        'de' => array(
-          array(
-            'value' => $this->randomName(),
-          ),
-        ),
-      ),
-      'field_test_text' => array(
-        'und' => array(
-          array(
-            'value' => $this->randomName(),
-            'format' => 'full_html',
-          ),
-        ),
-      ),
-    );
-
-    // Test valid request.
-    $entity = $this->normalizers['entity']->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', static::$format);
-    $this->assertEqual('entity_test', $entity->bundle(), "Denormalize creates entity with correct bundle.");
-    $this->assertEqual($incoming_data['name']['en'], $entity->get('name')->getValue(), "Translatable field denormalized correctly in default language.");
-    $this->assertEqual($incoming_data['name']['de'], $entity->getTranslation('de')->get('name')->getValue(), "Translatable field denormalized correctly in translation language.");
-    $this->assertEqual($incoming_data['field_test_text']['und'], $entity->get('field_test_text')->getValue(), "Untranslatable field denormalized correctly.");
-
-    // Test request without @type.
-    unset($incoming_data['@type']);
-    try {
-      $this->normalizers['entity']->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', static::$format);
-      $this->fail('Trying to denormalize entity data without @type results in exception.');
-    }
-    catch (UnexpectedValueException $e) {
-      $this->pass('Trying to denormalize entity data without @type results in exception.');
-    }
-
-    // Test request with @type that has no valid mapping.
-    $incoming_data['@type'] = 'http://failing-uri.com/type';
-    try {
-      $this->normalizers['entity']->denormalize($incoming_data, 'Drupal\Core\Entity\EntityNG', static::$format);
-      $this->fail('Trying to denormalize entity data with unrecognized @type results in exception.');
-    }
-    catch (UnexpectedValueException $e) {
-      $this->pass('Trying to denormalize entity data with unrecognized @type results in exception.');
-    }
-  }
-
-  /**
-   * Get the Entity ID.
-   *
-   * @param \Drupal\Core\Entity\EntityNG $entity
-   *   Entity to get URI for.
-   *
-   * @return string
-   *   Return the entity URI.
-   */
-  protected function getEntityId($entity) {
-    global $base_url;
-    $uriInfo = $entity->uri();
-    return $base_url . '/' . $uriInfo['path'];
-  }
-
-}
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizeTest.php b/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizeTest.php
new file mode 100644
index 0000000..f8f8f59
--- /dev/null
+++ b/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizeTest.php
@@ -0,0 +1,116 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\jsonld\Tests\NormalizeTest.
+ */
+
+namespace Drupal\jsonld\Tests;
+
+/**
+ * Test the vendor specific JSON-LD normalizer.
+ */
+class NormalizeTest extends NormalizerTestBase {
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Normalize Test',
+      'description' => 'Test that entities can be normalized in JSON-LD.',
+      'group' => 'JSON-LD',
+    );
+  }
+
+  /**
+   * Tests the normalize function.
+   */
+  public function testNormalize() {
+    // Create a German entity.
+    $values = array(
+      'langcode' => 'de',
+      'name' => $this->randomName(),
+      'user_id' => 1,
+      'field_test_text' => array(
+        'value' => $this->randomName(),
+        'format' => 'full_html',
+      ),
+    );
+    // Array of translated values.
+    $translationValues = array(
+      'name' => $this->randomName(),
+    );
+
+    $entity = entity_create('entity_test', $values);
+    $entity->save();
+    // Add an English value for name property.
+    $entity->getTranslation('en')->set('name', array(0 => array('value' => $translationValues['name'])));
+
+    $expectedArray = array(
+      '@id' => $this->getEntityId($entity),
+      'uuid' => array(
+        'und' => array(
+          array(
+            'value' => $entity->uuid(),
+          ),
+        ),
+      ),
+      'user_id' => array(
+        'de' => array(
+          array(
+            '@id' => url('user/' . $values['user_id'], array('absolute' => TRUE)),
+          ),
+        ),
+      ),
+      'name' => array(
+        'de' => array(
+          array(
+            'value' => $values['name'],
+          ),
+        ),
+        'en' => array(
+          array(
+            'value' => $translationValues['name'],
+          ),
+        ),
+      ),
+      'field_test_text' => array(
+        'und' => array(
+          array(
+            'value' => $values['field_test_text']['value'],
+            'format' => $values['field_test_text']['format'],
+          ),
+        ),
+      ),
+    );
+
+    $normalized = $this->container->get('serializer')->normalize($entity, $this->format);
+    // Test ordering. The @context and @id properties should always be first.
+    $keys = array_keys($normalized);
+    $this->assertEqual($keys[0], '@id', '@id and @context attributes placed correctly.');
+    // Test @id value.
+    $this->assertEqual($normalized['@id'], $expectedArray['@id'], '@id uses correct value.');
+    // Test non-translatable field.
+    $this->assertEqual($normalized['uuid'], $expectedArray['uuid'], 'Non-translatable fields are nested correctly.');
+    // Test single-language translatable.
+    $this->assertEqual($normalized['user_id'], $expectedArray['user_id'], 'Translatable field with single language value is nested correctly.');
+    // Test multi-language translatable.
+    $this->assertEqual($normalized['name'], $expectedArray['name'], 'Translatable field with multiple language values is nested correctly.');
+    // Test multi-property untranslatable field.
+    $this->assertEqual($normalized['field_test_text'], $expectedArray['field_test_text'], 'Field with properties is nested correctly.');
+  }
+
+  /**
+   * Get the Entity ID.
+   *
+   * @param \Drupal\Core\Entity\EntityNG $entity
+   *   Entity to get URI for.
+   *
+   * @return string
+   *   Return the entity URI.
+   */
+  protected function getEntityId($entity) {
+    global $base_url;
+    $uriInfo = $entity->uri();
+    return $base_url . '/' . $uriInfo['path'];
+  }
+
+}
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizerTestBase.php b/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizerTestBase.php
new file mode 100644
index 0000000..4b5cd8b
--- /dev/null
+++ b/core/modules/jsonld/lib/Drupal/jsonld/Tests/NormalizerTestBase.php
@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\jsonld\Tests\NormalizerTestBase.
+ */
+
+namespace Drupal\jsonld\Tests;
+
+use Drupal\Core\Language\Language;
+use Drupal\rdf\SiteSchema\SiteSchema;
+use Drupal\simpletest\DrupalUnitTestBase;
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
+
+/**
+ * Test the vendor specific JSON-LD normalizer.
+ *
+ * This is implemented as a WebTest because it requires use of the Entity API.
+ */
+abstract class NormalizerTestBase extends DrupalUnitTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('field', 'field_sql_storage', 'language', 'system', 'text', 'serialization');
+
+  /**
+   * The entity type used for testing.
+   *
+   * @var string
+   */
+  protected $entityType = 'entity_test';
+
+  /**
+   * The bundle used for testing.
+   *
+   * @var string
+   */
+  protected $bundle = 'entity_test';
+
+  /**
+   * The format being tested.
+   */
+  protected $format = 'drupal_jsonld';
+
+  /**
+   * Overrides \Drupal\simpletest\DrupalUnitTestBase::setup().
+   */
+  function setUp() {
+    parent::setUp();
+    $this->installSchema('system', 'variable');
+    $this->installSchema('system', 'url_alias');
+    $this->installSchema('field', 'field_config');
+    $this->installSchema('field', 'field_config_instance');
+
+    // English must be added before entity_test is enabled.
+    $this->enableModules(array('language'));
+    $english = new Language(array(
+      'langcode' => 'en',
+      'name' => 'English',
+    ));
+    language_save($english);
+    // Add German as a language.
+    $german = new Language(array(
+      'langcode' => 'de',
+      'name' => 'Deutsch',
+    ));
+    language_save($german);
+
+    $this->enableModules(array('entity_test', 'serialization', 'rdf', 'jsonld', 'user'));
+  }
+
+}
diff --git a/core/modules/jsonld/lib/Drupal/jsonld/Tests/SupportsSerializationTest.php b/core/modules/jsonld/lib/Drupal/jsonld/Tests/SupportsSerializationTest.php
index 38cee8a..5e5698b 100644
--- a/core/modules/jsonld/lib/Drupal/jsonld/Tests/SupportsSerializationTest.php
+++ b/core/modules/jsonld/lib/Drupal/jsonld/Tests/SupportsSerializationTest.php
@@ -8,24 +8,12 @@
 namespace Drupal\jsonld\Tests;
 
 use Drupal\config\Tests\ConfigEntityTest;
-use Drupal\simpletest\WebTestBase;
+use Drupal\jsonld\Tests\NormalizerTestBase;
 
 /**
  * Test the vendor specific JSON-LD normalizer.
  */
-class SupportsSerializationTest extends WebTestBase {
-
-  /**
-   * Modules to enable.
-   *
-   * @var array
-   */
-  public static $modules = array('entity_test', 'jsonld');
-
-  /**
-   * The format being tested.
-   */
-  protected static $format = 'drupal_jsonld';
+class SupportsSerializationTest extends NormalizerTestBase {
 
   /**
    * The Normalizers to be tested.
@@ -54,28 +42,28 @@ function setUp() {
    * Tests the supportsNormalization function.
    */
   public function testSupportsNormalization() {
-    $format = static::$format;
+    $format = $this->format;
     $supportedEntity = entity_create('entity_test', array());
     $unsupportedEntity = new ConfigEntityTest();
     $field = $supportedEntity->get('uuid');
     $entityreferenceField = $supportedEntity->get('user_id');
 
     // Supported entity.
-    $this->assertTrue($this->normalizers['entity']->supportsNormalization($supportedEntity, static::$format), "Entity normalization is supported for $format on content entities.");
+    $this->assertTrue($this->normalizers['entity']->supportsNormalization($supportedEntity, $format), "Entity normalization is supported for $format on content entities.");
     // Unsupported entity.
-    $this->assertFalse($this->normalizers['entity']->supportsNormalization($unsupportedEntity, static::$format), "Normalization is not supported for other entity types.");
+    $this->assertFalse($this->normalizers['entity']->supportsNormalization($unsupportedEntity, $format), "Normalization is not supported for other entity types.");
 
     // Field item.
-    $this->assertTrue($this->normalizers['field_item']->supportsNormalization($field->offsetGet(0), static::$format), "Field item normalization is supported for $format.");
+    $this->assertTrue($this->normalizers['field_item']->supportsNormalization($field->offsetGet(0), $format), "Field item normalization is supported for $format.");
     // Entity reference field item.
-    $this->assertTrue($this->normalizers['entityreference']->supportsNormalization($entityreferenceField->offsetGet(0), static::$format), "Entity reference field item normalization is supported for $format.");
+    $this->assertTrue($this->normalizers['entityreference']->supportsNormalization($entityreferenceField->offsetGet(0), $format), "Entity reference field item normalization is supported for $format.");
   }
 
   /**
    * Tests the supportsDenormalization function.
    */
   public function testSupportsDenormalization() {
-    $format = static::$format;
+    $format = $this->format;
     $data = array();
     $supportedEntityClass = 'Drupal\Core\Entity\EntityNG';
     $unsupportedEntityClass = 'Drupal\config\Tests\ConfigEntityTest';
@@ -83,14 +71,14 @@ public function testSupportsDenormalization() {
     $entityreferenceFieldClass = 'Drupal\Core\Entity\Field\Type\EntityReferenceItem';
 
     // Supported entity.
-    $this->assertTrue($this->normalizers['entity']->supportsDenormalization($data, $supportedEntityClass, static::$format), "Entity denormalization is supported for $format on content entities.");
+    $this->assertTrue($this->normalizers['entity']->supportsDenormalization($data, $supportedEntityClass, $format), "Entity denormalization is supported for $format on content entities.");
     // Unsupported entity.
-    $this->assertFalse($this->normalizers['entity']->supportsDenormalization($data, $unsupportedEntityClass, static::$format), "Denormalization is not supported for other entity types.");
+    $this->assertFalse($this->normalizers['entity']->supportsDenormalization($data, $unsupportedEntityClass, $format), "Denormalization is not supported for other entity types.");
 
     // Field item.
-    $this->assertTrue($this->normalizers['field_item']->supportsDenormalization($data, $fieldClass, static::$format), "Field item denormalization is supported for $format.");
+    $this->assertTrue($this->normalizers['field_item']->supportsDenormalization($data, $fieldClass, $format), "Field item denormalization is supported for $format.");
     // Entity reference field item.
-    $this->assertTrue($this->normalizers['entityreference']->supportsDenormalization($data, $entityreferenceFieldClass, static::$format), "Entity reference field item denormalization is supported for $format.");
+    $this->assertTrue($this->normalizers['entityreference']->supportsDenormalization($data, $entityreferenceFieldClass, $format), "Entity reference field item denormalization is supported for $format.");
   }
 
 }
diff --git a/core/modules/serialization/lib/Drupal/serialization/Normalizer/NormalizerBase.php b/core/modules/serialization/lib/Drupal/serialization/Normalizer/NormalizerBase.php
index c30cd3e..f293781 100644
--- a/core/modules/serialization/lib/Drupal/serialization/Normalizer/NormalizerBase.php
+++ b/core/modules/serialization/lib/Drupal/serialization/Normalizer/NormalizerBase.php
@@ -7,6 +7,7 @@
 
 namespace Drupal\serialization\Normalizer;
 
+use Drupal\serialization\Plugin\Type\EntityReferenceHandlerPluginManager;
 use Symfony\Component\Serializer\Exception\RuntimeException;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\SerializerAwareNormalizer;
@@ -23,6 +24,8 @@
    */
   protected static $supportedInterfaceOrClass;
 
+  protected $entityReferenceHandlerPluginManager;
+
   /**
    * Implements \Symfony\Component\Serializer\Normalizer\NormalizerInterface::supportsNormalization().
    */
@@ -30,4 +33,8 @@ public function supportsNormalization($data, $format = NULL) {
     return is_object($data) && ($data instanceof static::$supportedInterfaceOrClass);
   }
 
+  public function setEntityReferenceHandlerPluginManager(EntityReferenceHandlerPluginManager $plugin_manager) {
+    $this->entityReferenceHandlerPluginManager = $plugin_manager;
+  }
+
 }
diff --git a/core/modules/serialization/lib/Drupal/serialization/Plugin/Core/Entity/EntityReferenceHandlerSettings.php b/core/modules/serialization/lib/Drupal/serialization/Plugin/Core/Entity/EntityReferenceHandlerSettings.php
new file mode 100644
index 0000000..5095a72
--- /dev/null
+++ b/core/modules/serialization/lib/Drupal/serialization/Plugin/Core/Entity/EntityReferenceHandlerSettings.php
@@ -0,0 +1,107 @@
+<?php
+/**
+ * @file
+ * Contains Drupal/serialization/Plugin/Core/Entity/EntityReferenceHandlerSettings
+ */
+
+namespace Drupal\serialization\Plugin\Core\Entity;
+
+use Drupal\Core\Config\Entity\ConfigEntityBase;
+use Drupal\Core\Annotation\Plugin;
+use Drupal\Core\Annotation\Translation;
+
+/**
+ * Configuration entity specifying how entity references should be imported.
+ *
+ * @Plugin(
+ *   id = "entityreference_handler_settings",
+ *   label = @Translation("Entity reference handler settings"),
+ *   module = "serialization",
+ *   controller_class = "Drupal\Core\Config\Entity\ConfigStorageController",
+ *   config_prefix = "serialization.entityreference",
+ *   entity_keys = {
+ *     "id" = "id",
+ *     "uuid" = "uuid"
+ *   }
+ * )
+ */
+class EntityReferenceHandlerSettings extends ConfigEntityBase {
+
+  /**
+   * Unique ID for the config entity.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * Unique UUID for the config entity.
+   *
+   * @var string
+   */
+  public $uuid;
+
+  /**
+   * The short name of the serialization format.
+   *
+   * @var string
+   */
+  public $format;
+
+  /**
+   * List of entity reference field handlers, keyed by format and field name.
+   *
+   * @var array
+   */
+  public $entityreferenceHandlers = array();
+
+  /**
+   * Overrides \Drupal\Core\Entity\Entity::id().
+   */
+  public function id() {
+    return $this->format;
+  }
+
+  /**
+   * Overrides \Drupal\config\ConfigEntityBase::save().
+   */
+  public function save() {
+    // Build an ID if none is set.
+    if (empty($this->id)) {
+      $this->id = $this->id();
+    }
+    return parent::save();
+  }
+
+  /**
+   * Sets the Entity Reference Handler to use when deserializing this field.
+   *
+   * @param $field_name
+   *   Name of the field which the handler will handle.
+   * @param $handler_name
+   *   The plugin id of the handler.
+   */
+  public function setHandler($field_name, $handler_name) {
+    $this->entityreferenceHandlers[$field_name] = $handler_name;
+  }
+
+  /**
+   * Gets the Entity Reference Handler to use when deserializing this field.
+   *
+   * @param $field_name
+   *   Name of the field which the handler will handle.
+   *
+   * @return string
+   *   The plugin id of the handler.
+   */
+  public function getHandler($field_name) {
+    if (isset($this->entityreferenceHandlers[$field_name])) {
+      return $this->entityreferenceHandlers[$field_name];
+    }
+    else {
+      // @todo Make it possible to configure a default per format.
+      return 'null_value';
+    }
+  }
+
+}
diff --git a/core/modules/serialization/lib/Drupal/serialization/Plugin/EntityReferenceHandlerInterface.php b/core/modules/serialization/lib/Drupal/serialization/Plugin/EntityReferenceHandlerInterface.php
new file mode 100644
index 0000000..c633703
--- /dev/null
+++ b/core/modules/serialization/lib/Drupal/serialization/Plugin/EntityReferenceHandlerInterface.php
@@ -0,0 +1,21 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\serialization\Plugin\EntityReferenceHandlerInterface;
+ */
+
+namespace Drupal\serialization\Plugin;
+
+/**
+ * Specifies the public methods of an entity reference handler plugin.
+ */
+interface EntityReferenceHandlerInterface {
+
+  /**
+   * Get the entity ID of the referenced entity.
+   *
+   * @return int
+   */
+  public function getEntityId($normalizer);
+}
diff --git a/core/modules/serialization/lib/Drupal/serialization/Plugin/Type/EntityReferenceHandlerPluginManager.php b/core/modules/serialization/lib/Drupal/serialization/Plugin/Type/EntityReferenceHandlerPluginManager.php
new file mode 100644
index 0000000..e33fdf3
--- /dev/null
+++ b/core/modules/serialization/lib/Drupal/serialization/Plugin/Type/EntityReferenceHandlerPluginManager.php
@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal/serialization/Plugin/Type/EntityReferenceHandlerPluginManager
+ */
+
+namespace Drupal\serialization\Plugin\Type;
+
+use Drupal\Component\Plugin\PluginManagerBase;
+use Drupal\Core\Plugin\Discovery\AnnotatedClassDiscovery;
+use Drupal\Component\Plugin\Factory\DefaultFactory;
+
+/**
+ * Defines the plugin manager for Entity Reference Handler plugins.
+ */
+class EntityReferenceHandlerPluginManager extends PluginManagerBase {
+
+  /**
+   * Overrides Drupal\Component\Plugin\PluginManagerBase::__construct().
+   */
+  public function __construct() {
+    $this->discovery = new AnnotatedClassDiscovery('serialization', 'entityreference_handler');
+    $this->factory = new DefaultFactory($this);
+  }
+
+  /**
+   * Overrides \Drupal\Component\Plugin\PluginManagerBase::getInstance().
+   */
+  public function getInstance(array $options) {
+    $format = $options['format'];
+    $handler = $this->getHandler($format, $options['field_name']);
+    $config = array(
+      'target_type' => $options['field']['settings']['target_type'],
+    );
+    return $this->createInstance($handler, $config);
+  }
+
+  /**
+   * @param $format
+   *   The format being deserialized to.
+   * @param $field_name
+   *   The field name.
+   *
+   * @return string
+   *   The plugin id for the handler.
+   */
+  protected function getHandler($format, $field_name) {
+    $entityreference_settings = entity_load('entityreference_handler_settings', $format);
+    if (!isset($entityreference_settings)) {
+      // @todo Load the default.
+    }
+    return $entityreference_settings->getHandler($field_name);
+  }
+}
diff --git a/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/NullValue.php b/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/NullValue.php
new file mode 100644
index 0000000..b5ab78a
--- /dev/null
+++ b/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/NullValue.php
@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal/rest/Plugin/rest/entityreference_handler/NullValue
+ */
+
+namespace Drupal\serialization\Plugin\serialization\entityreference_handler;
+
+use Drupal\Core\Annotation\Plugin;
+use Drupal\Core\Annotation\Translation;
+use Drupal\serialization\Plugin\EntityReferenceHandlerInterface;
+/**
+ * Provides an entity reference handler which does not resolve the value.
+ *
+ * This is helpful in cases where you will overwrite the value with a default
+ * or configured value in post-processing.
+ *
+ * @Plugin(
+ *   id = "null_value",
+ *   label = @Translation("Null value")
+ * )
+ */
+class NullValue implements EntityReferenceHandlerInterface {
+
+  /**
+   * Implements EntityReferenceHandlerInterface::getEntityId()
+   */
+  public function getEntityId($normalizer) {
+    return NULL;
+  }
+}
diff --git a/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/Uuid.php b/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/Uuid.php
new file mode 100644
index 0000000..4de06b6
--- /dev/null
+++ b/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/Uuid.php
@@ -0,0 +1,34 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\serialization\Plugin\serialization\entityreference_handler\Uuid
+ */
+
+namespace Drupal\serialization\Plugin\serialization\entityreference_handler;
+
+use Drupal\Component\Plugin\PluginBase;
+use Drupal\Core\Annotation\Plugin;
+use Drupal\Core\Annotation\Translation;
+use Drupal\serialization\Plugin\EntityReferenceHandlerInterface;
+/**
+ * Provides an entity reference handler for matching based on UUID.
+ *
+ * @Plugin(
+ *   id = "uuid",
+ *   label = @Translation("UUID match")
+ * )
+ */
+class Uuid extends PluginBase implements EntityReferenceHandlerInterface {
+
+  /**
+   * Implements EntityReferenceHandlerInterface::getEntityId()
+   */
+  public function getEntityId($normalizer) {
+    if (($normalizer instanceof UuidReferenceInterface) && $uuid = $normalizer->getUuid()) {
+      $entity = entity_load_by_uuid($this->configuration['target_type'], $uuid);
+      return $entity->id();
+    }
+  }
+
+}
diff --git a/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/UuidReferenceInterface.php b/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/UuidReferenceInterface.php
new file mode 100644
index 0000000..d4e6b5d
--- /dev/null
+++ b/core/modules/serialization/lib/Drupal/serialization/Plugin/serialization/entityreference_handler/UuidReferenceInterface.php
@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\serialization\ReferenceHandler\UuidReferenceInterface
+ */
+
+namespace Drupal\serialization\Plugin\serialization\entityreference_handler;
+
+/**
+ * Interface for extracting UUID from entity reference data when denormalizing.
+ */
+interface UuidReferenceInterface {
+
+  /**
+   * Get the uuid from the data array.
+   *
+   * @return string
+   *   A UUID.
+   */
+  public function getUuid();
+
+}
diff --git a/core/modules/serialization/lib/Drupal/serialization/RegisterSerializationClassesCompilerPass.php b/core/modules/serialization/lib/Drupal/serialization/RegisterSerializationClassesCompilerPass.php
index e48af2e..cb2919c 100644
--- a/core/modules/serialization/lib/Drupal/serialization/RegisterSerializationClassesCompilerPass.php
+++ b/core/modules/serialization/lib/Drupal/serialization/RegisterSerializationClassesCompilerPass.php
@@ -17,7 +17,7 @@
 class RegisterSerializationClassesCompilerPass implements CompilerPassInterface {
 
   /**
-   * Adds services to the Serializer.
+   * Adds services to the Serializer and sets format-based parameters.
    *
    * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
    *   The container to process.
diff --git a/core/modules/serialization/lib/Drupal/serialization/SerializationBundle.php b/core/modules/serialization/lib/Drupal/serialization/SerializationBundle.php
index a2744b5..a748e9e 100644
--- a/core/modules/serialization/lib/Drupal/serialization/SerializationBundle.php
+++ b/core/modules/serialization/lib/Drupal/serialization/SerializationBundle.php
@@ -19,6 +19,8 @@ class SerializationBundle extends Bundle {
    * Overrides \Symfony\Component\HttpKernel\Bundle\Bundle::build().
    */
   public function build(ContainerBuilder $container) {
+    // Register the entity reference handler plugin manager class.
+    $container->register('plugin.manager.serialization.entityreference_handler', 'Drupal\serialization\Plugin\Type\EntityReferenceHandlerPluginManager');
     // Add Serializer with arguments to be replaced in the compiler pass.
     $container->register('serializer', 'Symfony\Component\Serializer\Serializer')
       ->addArgument(array())
diff --git a/core/modules/serialization/lib/Drupal/serialization/Tests/EntityReferenceHandlerSettingsTest.php b/core/modules/serialization/lib/Drupal/serialization/Tests/EntityReferenceHandlerSettingsTest.php
new file mode 100644
index 0000000..decbf26
--- /dev/null
+++ b/core/modules/serialization/lib/Drupal/serialization/Tests/EntityReferenceHandlerSettingsTest.php
@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\serialization\Tests\EntityReferenceHandlerSettingsTest
+ */
+
+namespace Drupal\serialization\Tests;
+
+use Drupal\serialization\Plugin\serialization\entityreference_handler\ConfiguredValue;
+use Drupal\simpletest\DrupalUnitTestBase;
+
+class EntityReferenceHandlerSettingsTest extends DrupalUnitTestBase {
+
+  public static $modules = array('entity', 'serialization');
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Entity Reference Deserialize Settings Test',
+      'description' => "Tests the Entity Reference Deserialize Settings config object.",
+      'group' => 'Serialization',
+    );
+  }
+
+  public function testSetGet() {
+    $format = 'drupal_jsonld';
+    $config = entity_create('entityreference_handler_settings', array('format' => 'drupal_jsonld',));
+    $config->setHandler('user_id', 'configured_value', array('value' => 1));
+    $config->save();
+
+    $loadedConfig = entity_load('entityreference_handler_settings', $format);
+    // Test that setHandler works.
+    $expected = array (
+      'user_id' => array(
+        'plugin_id' => 'null_value',
+      ),
+    );
+    $this->assertEqual($expected, $loadedConfig->get('entityreferenceHandlers'), 'setHandler() sets the appropriate handler.');
+
+    // Test that getHandler works.
+    $handler = $loadedConfig->getHandler('user_id');
+    $this->assertEqual($handler, $expected['user_id'], 'getHandler() returns the handler name.');
+  }
+}
diff --git a/core/modules/serialization/serialization.module b/core/modules/serialization/serialization.module
index b3d9bbc..ab16759 100644
--- a/core/modules/serialization/serialization.module
+++ b/core/modules/serialization/serialization.module
@@ -1 +1,10 @@
 <?php
+
+/**
+ * @file
+ * Manage the serialization system.
+ *
+ * The module is mostly an anchor point for configuration items owned by the
+ * serialization system.
+ */
+