Java Schema类代码示例

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Override
public void extendJPAEdmSchema(JPAEdmSchemaView view) {
	ResourceBundle i18n = ODataContextUtil.getResourceBundle("i18n");
	final Schema edmSchema = view.getEdmSchema();
	
	for (EntityType entityType : edmSchema.getEntityTypes()) {
		for (Property property : entityType.getProperties()) {
			String label = null;
			if (i18n != null) { try { label = i18n.getString(entityType.getName() + "." + property.getName()); } catch (Exception e) {} }
			List<AnnotationAttribute> annotationAttributeList = new ArrayList<AnnotationAttribute>();
			if (label != null) {
				annotationAttributeList.add(new AnnotationAttribute()
						.setNamespace(SAP_NAMESPACE)
						.setPrefix(SAP_PREFIX)
						.setName(LABEL).setText(label));
			}
			annotationAttributeList.addAll(getSapPropertyAnnotations(entityType, property));
			property.setAnnotationAttributes(annotationAttributeList); 
		}
	}
	
	addSmartAnnotations(edmSchema);
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test
public void loadAnnotatedClassesFromPackage() throws Exception {
  AnnotationEdmProvider localAep = new AnnotationEdmProvider(TEST_MODEL_PACKAGE);

  // validate employee
  EntityType employee = localAep.getEntityType(new FullQualifiedName(ModelSharedConstants.NAMESPACE_1, "Employee"));
  assertEquals("Employee", employee.getName());
  final List<PropertyRef> employeeKeys = employee.getKey().getKeys();
  assertEquals(1, employeeKeys.size());
  assertEquals("EmployeeId", employeeKeys.get(0).getName());
  assertEquals(6, employee.getProperties().size());
  assertEquals(3, employee.getNavigationProperties().size());

  List<Schema> schemas = localAep.getSchemas();
  assertEquals(1, schemas.size());
  EntityContainerInfo info = localAep.getEntityContainerInfo(ModelSharedConstants.CONTAINER_1);
  assertTrue(info.isDefaultEntityContainer());
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test
public void schemaBasic() throws Exception {
  assertNotNull(aep);

  List<Schema> schemas = aep.getSchemas();
  assertEquals(1, schemas.size());

  Schema schema = schemas.get(0);
  List<EntityContainer> containers = schema.getEntityContainers();
  assertEquals(1, containers.size());
  EntityContainer container = containers.get(0);
  assertEquals(ModelSharedConstants.CONTAINER_1, container.getName());
  final List<EntitySet> entitySets = container.getEntitySets();
  assertEquals(6, entitySets.size());

  List<Association> associations = schema.getAssociations();
  assertEquals(5, associations.size());
  for (Association association : associations) {
    assertNotNull(association.getName());
    validateAssociation(association);
  }
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Override
public Association getAssociation(final FullQualifiedName edmFQName) throws ODataException {
  if (edmFQName != null) {
    if (associations.containsKey(edmFQName.toString())) {
      return associations.get(edmFQName.toString());
    } else if (schemas == null) {
      getSchemas();
    }

    for (Schema schema : schemas) {
      if (schema.getNamespace().equals(edmFQName.getNamespace())) {
        if (schema.getAssociations() == null) {
          return null;
        }
        for (Association association : schema.getAssociations()) {
          if (association.getName().equals(edmFQName.getName())) {
            associations.put(edmFQName.toString(), association);
            return association;
          }
        }
      }
    }

  }
  return null;
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Override
public List<EdmEntitySetInfo> getEntitySetInfos() throws ODataException {
  if (entitySetInfos == null) {
    entitySetInfos = new ArrayList<EdmEntitySetInfo>();

    if (schemas == null) {
      schemas = edmProvider.getSchemas();
    }

    for (Schema schema : schemas) {
      for (EntityContainer entityContainer : listOrEmptyList(schema.getEntityContainers())) {
        for (EntitySet entitySet : listOrEmptyList(entityContainer.getEntitySets())) {
          EdmEntitySetInfo entitySetInfo = new EdmEntitySetInfoImplProv(entitySet, entityContainer);
          entitySetInfos.add(entitySetInfo);
        }
      }
    }

  }

  return entitySetInfos;
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Override
public AssociationSet getAssociationSet(final String entityContainer, final FullQualifiedName association,
    final String sourceEntitySetName, final String sourceEntitySetRole) throws ODataException {
  for (Schema schema : dataServices.getSchemas()) {
    for (EntityContainer container : schema.getEntityContainers()) {
      if (container.getName().equals(entityContainer)) {
        for (AssociationSet associationSet : container.getAssociationSets()) {
          if (associationSet.getAssociation().equals(association)
              && ((associationSet.getEnd1().getEntitySet().equals(sourceEntitySetName) && associationSet.getEnd1()
                  .getRole().equals(sourceEntitySetRole))
              || (associationSet.getEnd2().getEntitySet().equals(sourceEntitySetName) && associationSet.getEnd2()
                  .getRole().equals(sourceEntitySetRole)))) {
            return associationSet;
          }
        }
      }
    }
  }
  return null;
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Override
protected List<EdmEntitySet> createEntitySets() throws ODataException {
  List<EdmEntitySet> edmEntitySets = new ArrayList<EdmEntitySet>();
  if (schemas == null) {
    schemas = edmProvider.getSchemas();
  }
  for (Schema schema : schemas) {
    for (EntityContainer entityContainer : schema.getEntityContainers()) {
      for (EntitySet entitySet : entityContainer.getEntitySets()) {
        EdmEntityContainer edmEntityContainer = createEntityContainer(entityContainer.getName());
        edmEntitySets.add(new EdmEntitySetImplProv(this, entitySet, edmEntityContainer));
      }
    }
  }
  return edmEntitySets;
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Override
protected List<EdmFunctionImport> createFunctionImports() throws ODataException {
  List<EdmFunctionImport> edmFunctionImports = new ArrayList<EdmFunctionImport>();
  if (schemas == null) {
    schemas = edmProvider.getSchemas();
  }
  for (Schema schema : schemas) {
    for (EntityContainer entityContainer : schema.getEntityContainers()) {
      for (FunctionImport functionImport : entityContainer.getFunctionImports()) {
        EdmEntityContainer edmEntityContainer = createEntityContainer(entityContainer.getName());
        edmFunctionImports.add(new EdmFunctionImportImplProv(this, functionImport, edmEntityContainer));
      }
    }
  }
  return edmFunctionImports;
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test(expected = Exception.class)
public void writeInvalidMetadata() throws Exception {
  disableLogging(this.getClass());
  List<Schema> schemas = new ArrayList<Schema>();

  List<AnnotationElement> annotationElements = new ArrayList<AnnotationElement>();
  annotationElements.add(new AnnotationElement().setText("hallo"));
  Schema schema = new Schema().setAnnotationElements(annotationElements);
  schema.setNamespace("http://namespace.com");
  schemas.add(schema);

  DataServices data = new DataServices().setSchemas(schemas).setDataServiceVersion(ODataServiceVersion.V20);
  OutputStreamWriter writer = null;
  CircleStreamBuffer csb = new CircleStreamBuffer();
  writer = new OutputStreamWriter(csb.getOutputStream(), "UTF-8");
  XMLStreamWriter xmlStreamWriter = xmlStreamWriterFactory.createXMLStreamWriter(writer);
  XmlMetadataProducer.writeMetadata(data, xmlStreamWriter, null);
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Before
public void before() throws ODataException {
  Map<String, String> prefixMap = new HashMap<String, String>();
  prefixMap.put("atom", Edm.NAMESPACE_ATOM_2005);
  prefixMap.put("a", Edm.NAMESPACE_APP_2007);
  prefixMap.put("xml", Edm.NAMESPACE_XML_1998);
  prefixMap.put("custom", "http://localhost");
  XMLUnit.setXpathNamespaceContext(new SimpleNamespaceContext(prefixMap));

  schemas = new ArrayList<Schema>();

  EdmProvider edmProvider = mock(EdmProvider.class);
  when(edmProvider.getSchemas()).thenReturn(schemas);

  EdmServiceMetadata edmServiceMetadata = new EdmServiceMetadataImplProv(edmProvider);

  edm = mock(Edm.class);
  when(edm.getServiceMetadata()).thenReturn(edmServiceMetadata);
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test
public void writeServiceDocumentWithOneEnitySetOneContainerOneSchema() throws Exception {
  List<EntitySet> entitySets = new ArrayList<EntitySet>();
  entitySets.add(new EntitySet().setName("Employees"));

  List<EntityContainer> entityContainers = new ArrayList<EntityContainer>();
  entityContainers.add(new EntityContainer().setDefaultEntityContainer(true).setName("Container").setEntitySets(
      entitySets));

  schemas.add(new Schema().setEntityContainers(entityContainers));

  ODataResponse response = new AtomEntityProvider().writeServiceDocument(edm, "http://localhost");
  String xmlString = verifyResponse(response);
  assertXpathExists("/a:service/a:workspace/a:collection[@href='Employees']", xmlString);
  assertXpathExists("/a:service/a:workspace/a:collection[@href='Employees']/atom:title", xmlString);
  assertXpathEvaluatesTo("Employees", "/a:service/a:workspace/a:collection[@href='Employees']/atom:title", xmlString);
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test
public void writeServiceDocumentWithOneEnitySetTwoContainersOneSchema() throws Exception {
  List<EntitySet> entitySets = new ArrayList<EntitySet>();
  entitySets.add(new EntitySet().setName("Employees"));

  List<EntityContainer> entityContainers = new ArrayList<EntityContainer>();
  entityContainers.add(new EntityContainer().setDefaultEntityContainer(true).setName("Container").setEntitySets(
      entitySets));
  entityContainers.add(new EntityContainer().setDefaultEntityContainer(false).setName("Container2").setEntitySets(
      entitySets));

  schemas.add(new Schema().setEntityContainers(entityContainers));

  ODataResponse response = new AtomEntityProvider().writeServiceDocument(edm, "http://localhost");
  String xmlString = verifyResponse(response);
  assertXpathExists("/a:service/a:workspace/a:collection[@href='Employees']", xmlString);
  assertXpathExists("/a:service/a:workspace/a:collection[@href='Employees']/atom:title", xmlString);
  assertXpathEvaluatesTo("Employees", "/a:service/a:workspace/a:collection[@href='Employees']/atom:title", xmlString);

  assertXpathExists("/a:service/a:workspace/a:collection[@href='Employees']", xmlString);
  assertXpathExists("/a:service/a:workspace/a:collection[@href='Employees']/atom:title", xmlString);
  assertXpathEvaluatesTo("Employees", "/a:service/a:workspace/a:collection[@href='Container2.Employees']/atom:title",
      xmlString);
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test
public void testBaseType() throws XMLStreamException, EntityProviderException {
  int i = 0;
  XmlMetadataConsumer parser = new XmlMetadataConsumer();
  XMLStreamReader reader = createStreamReader(xmlWithBaseType);
  DataServices result = parser.readMetadata(reader, true);
  assertEquals("2.0", result.getDataServiceVersion());
  for (Schema schema : result.getSchemas()) {
    assertEquals(NAMESPACE, schema.getNamespace());
    assertEquals(2, schema.getEntityTypes().size());
    assertEquals("Employee", schema.getEntityTypes().get(0).getName());
    for (PropertyRef propertyRef : schema.getEntityTypes().get(0).getKey().getKeys()) {
      assertEquals("EmployeeId", propertyRef.getName());
    }
    for (Property property : schema.getEntityTypes().get(0).getProperties()) {
      assertEquals(propertyNames[i], property.getName());
      i++;
    }

  }
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test
public void testTwoSchemas() throws XMLStreamException, EntityProviderException {
  int i = 0;
  String schemasNs[] = { NAMESPACE, NAMESPACE2 };
  XmlMetadataConsumer parser = new XmlMetadataConsumer();
  XMLStreamReader reader = createStreamReader(xmlWithTwoSchemas);
  DataServices result = parser.readMetadata(reader, true);
  assertEquals("2.0", result.getDataServiceVersion());
  assertEquals(2, result.getSchemas().size());
  for (Schema schema : result.getSchemas()) {
    assertEquals(schemasNs[i], schema.getNamespace());
    assertEquals(1, schema.getEntityTypes().size());
    i++;

  }
}
 

import org.apache.olingo.odata2.api.edm.provider.Schema; //导入依赖的package包/类
@Test
public void testAssociationSet() throws XMLStreamException, EntityProviderException {
  XmlMetadataConsumer parser = new XmlMetadataConsumer();
  XMLStreamReader reader = createStreamReader(xmlWithAssociation);
  DataServices result = parser.readMetadata(reader, true);
  for (Schema schema : result.getSchemas()) {
    for (EntityContainer container : schema.getEntityContainers()) {
      assertEquals(NAMESPACE2, schema.getNamespace());
      assertEquals("Container1", container.getName());
      assertEquals(Boolean.TRUE, container.isDefaultEntityContainer());
      for (AssociationSet assocSet : container.getAssociationSets()) {
        assertEquals(ASSOCIATION, assocSet.getName());
        assertEquals(ASSOCIATION, assocSet.getAssociation().getName());
        assertEquals(NAMESPACE, assocSet.getAssociation().getNamespace());
        AssociationSetEnd end;
        if ("Employees".equals(assocSet.getEnd1().getEntitySet())) {
          end = assocSet.getEnd1();
        } else {
          end = assocSet.getEnd2();
        }
        assertEquals("r_Employees", end.getRole());
      }
    }
  }
}