Olingo client的使用

最新推荐文章于 2024-04-19 11:57:29 发布
最新推荐文章于 2024-04-19 11:57:29 发布
阅读量1.7k 收藏
点赞数
分类专栏： java技术 文章标签： OData Olingo OData协议详解 Olingo client的使用 apache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq974816077/article/details/40189819
版权

原文来至:http://user.qzone.qq.com/974816077/2


上篇我们使用restFull来对OData service进行POST和PUT操作,麻烦的是我们必须要自己编写请求body. 如图:

 
<?xml version='1.0' encoding='utf-8'?>
< entry  xmlns = "http://www.w3.org/2005/Atom"
xmlns:m = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" 
xmlns:d = "http://schemas.microsoft.com/ado/2007/08/dataservices"
xml:base = "http://localhost:8080/odata2-jpa2/SemServiceServlet.svc/" >
< id >http://localhost:8080/odata2-jpa2/SemServiceServlet.svc/Departments(4) </ id >
< title  type = "text" >Departments </ title >
< updated >2014-10-17T15:15:57.071+08:00 </ updated >
< category  term = "odata2_jpa2.Department"  scheme = "http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />
< link  href = "Departments(4)"  rel = "edit"  title = "Department" />
< content  type = "application/xml" >
< m:properties >
< d:Id >4 </ d:Id >
< d:Name > 城 管 部 门 </ d:Name >
</ m:properties >
</ content >
</ entry >
 
这就是我们进行PUT更新Department时自己编写的请求body,相当麻烦,下面我们再介绍Olingo client 对这个请求头的封装与其使用方法:

client中创建Entity的源代码,这是创建Entity的主入口函数:
 
  public ODataEntry createEntry(Edm edm,  String serviceUri,  String contentType, 
       String entitySetName, Map < String,  Object > data)  throws  Exception {
     String absolutUri  = createUri(serviceUri, entitySetName,  null);
     return writeEntity(edm, absolutUri, entitySetName, data, contentType, HTTP_METHOD_POST);
  }
  createUri ( serviceUri ,  entitySetName ,  null );实际上就是拼接新的url请求路径, serviceUri=" http://localhost:8080/odata2-jpa2/SemServiceServlet.svc ";  entitySetName=" Departments "; 拼接出新的url=" http://localhost:8080/odata2-jpa2/SemServiceServlet.svc/Departments ";
 
接下再看  writeEntity ( edm ,  absolutUri ,  entitySetName ,  data ,  contentType ,  HTTP_METHOD_POST );方法:
 
  private ODataEntry writeEntity(Edm edm, String absolutUri, String entitySetName, 
      Map<String, Object> data, String contentType, String httpMethod) 
      throws EdmException, MalformedURLException, IOException, EntityProviderException, URISyntaxException {

    HttpURLConnection connection = initializeConnection(absolutUri, contentType, httpMethod);

    EdmEntityContainer entityContainer = edm.getDefaultEntityContainer();
    EdmEntitySet entitySet = entityContainer.getEntitySet(entitySetName);
    URI rootUri = new URI(entitySetName);

    EntityProviderWriteProperties properties = EntityProviderWriteProperties.serviceRoot(rootUri).build();
    // serialize data into ODataResponse object
    ODataResponse response = EntityProvider.writeEntry(contentType, entitySet, data, properties);
    // get (http) entity which is for default Olingo implementation an InputStream
    Object entity = response.getEntity();
    if (entity instanceof InputStream) {
      byte[] buffer = streamToArray((InputStream) entity);
      // just for logging
      String content = new String(buffer);
      print(httpMethod + " request on uri '" + absolutUri + "' with content:\n  " + content + "\n");
      //
      connection.getOutputStream().write(buffer);
    }

    // if a entity is created (via POST request) the response body contains the new created entity
    ODataEntry entry = null;
    HttpStatusCodes statusCode = HttpStatusCodes.fromStatusCode(connection.getResponseCode());
    if(statusCode == HttpStatusCodes.CREATED) {
      // get the content as InputStream and de-serialize it into an ODataEntry object
      InputStream content = connection.getInputStream();
      content = logRawContent(httpMethod + " request on uri '" + absolutUri + "' with content:\n  ", content, "\n");
      entry = EntityProvider.readEntry(contentType,
          entitySet, content, EntityProviderReadProperties.init().build());
    }

    //
    connection.disconnect();

    return entry;
  }
 
 不难看出该方法是在封装POST的请求报文,同时封装了http对 absolutUri 的请求,最后检查POST请求处理结果,如果 statusCode == HttpStatusCodes.CREATED 说明POST请求成功,最后再读取response的写入流转换成ODataEntry对象返回,
整个POST请求就结束了.

PUT更新实体,入口方法 updateEntry :
 
  public  void updateEntry(Edm edm,  String serviceUri,  String contentType,  String entitySetName, 
       String id, Map < String,  Object > data)  throws  Exception {
     String absolutUri  = createUri(serviceUri, entitySetName, id);
    writeEntity(edm, absolutUri, entitySetName, data, contentType, HTTP_METHOD_PUT);
  }
 
每个选项方法都需要一个 edm参数,这个参数就是?$metadata请求返回的实体数据模型对象,client中这样读取的:
 
 Edm edm  = clienApp.readEdm(serviceUrl);
  serviceUrl=" http://localhost:8080/odata2-jpa2/SemServiceServlet.svc ";底层会拼接成 http://localhost:8080/odata2-jpa2/SemServiceServlet.svc/$metadata的url请求. 如源代码:
 
public Edm readEdm( String serviceUrl)  throws IOException, ODataException {
    InputStream content  = execute(serviceUrl  + SEPARATOR  + METADATA, APPLICATION_XML, HTTP_METHOD_GET);
     return EntityProvider.readMetadata(content,  false);
  }
  SEPARATOR  ="/";
  METADATA=" $metadata ";

updateEntry(Edm edm,  String  serviceUri,  String  contentType,  String  entitySetName,   String  id, Map < String ,  Object >  data)方法中参数:
 contentType=" application/atom+xml ";表示拼接一个atom-xml格式的请求报文



.






   

entitySetName="Departments";
id这里的id是我们要更新的id值
 data是更新的实体数据,底层会拼接成一下形势的body:
 
< content  type = "application/xml" >
      < m:properties >
          < d:Id >5 </ d:Id >
      < d:Name > 游 戏 开 发 部 门 </ d:Name >
      </ m:properties >
   </ content >
 
 DELETE就很简单了,因为不需要传递body,只需要传递id就可以执行删除了,所有DELETE的入口方法是:
 
HttpStatusCodes statusCode  = clienApp.deleteEntry(serviceUrl,  "Departments",  "4");
 最终client会封装成url:http://localhost:8080/odata2-jpa2/SemServiceServlet.svc/Departments(4)的DELETE http请求方式.
 
 
   private  String createUri( String serviceUri,  String entitySetName,  String id) {
     return createUri(serviceUri, entitySetName, id,  null);
  }
   private  String createUri( String serviceUri,  String entitySetName,  String id,  String expand) {
     final  StringBuilder absolutUri  =  new  StringBuilder(serviceUri).append(SEPARATOR).append(entitySetName);
     if(id  !=  null) {
      absolutUri.append( "(").append(id).append( ")");
    }
     if(expand  !=  null) {
      absolutUri.append( "/?$expand=").append(expand);
    }
     return absolutUri.toString();
  }
 

下面是全部操作Olingo client的原代码,在main函数中有演示的方式调用,将该java文件拷贝到工程中就可以随意操作了:
 
package olingo.clien;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.olingo.odata2.api.commons.HttpStatusCodes;
import org.apache.olingo.odata2.api.edm.Edm;
import org.apache.olingo.odata2.api.edm.EdmEntityContainer;
import org.apache.olingo.odata2.api.edm.EdmEntitySet;
import org.apache.olingo.odata2.api.edm.EdmException;
import org.apache.olingo.odata2.api.ep.EntityProvider;
import org.apache.olingo.odata2.api.ep.EntityProviderException;
import org.apache.olingo.odata2.api.ep.EntityProviderReadProperties;
import org.apache.olingo.odata2.api.ep.EntityProviderWriteProperties;
import org.apache.olingo.odata2.api.ep.entry.ODataEntry;
import org.apache.olingo.odata2.api.ep.feed.ODataDeltaFeed;
import org.apache.olingo.odata2.api.ep.feed.ODataFeed;
import org.apache.olingo.odata2.api.exception.ODataException;
import org.apache.olingo.odata2.api.processor.ODataResponse;
/**
 * OlingoClienApp
 */
public  class OlingoClienApp {
   public  static  final  String HTTP_METHOD_PUT  =  "PUT";
   public  static  final  String HTTP_METHOD_POST  =  "POST";
   public  static  final  String HTTP_METHOD_GET  =  "GET";
   private  static  final  String HTTP_METHOD_DELETE  =  "DELETE";
   public  static  final  String HTTP_HEADER_CONTENT_TYPE  =  "Content-Type";
   public  static  final  String HTTP_HEADER_ACCEPT  =  "Accept";
   public  static  final  String APPLICATION_JSON  =  "application/json";
   public  static  final  String APPLICATION_XML  =  "application/xml";
   public  static  final  String APPLICATION_ATOM_XML  =  "application/atom+xml";
   public  static  final  String APPLICATION_FORM  =  "application/x-www-form-urlencoded";
   public  static  final  String METADATA  =  "$metadata";
   public  static  final  String INDEX  =  "/index.jsp";
   public  static  final  String SEPARATOR  =  "/";
   public  static  final  boolean PRINT_RAW_CONTENT  =  true;
  
  
   public  static  void main( String[] paras)  throws  Exception {
    OlingoClienApp clienApp  =  new OlingoClienApp();
     String serviceUrl  =  "http://localhost:8080/odata2-jpa2/SemServiceServlet.svc";
     String usedFormat  = APPLICATION_ATOM_XML;
//    String usedFormat = APPLICATION_JSON;
    print( "\n----- Generate sample data ------------------------------");
    clienApp.generateSampleData(serviceUrl);
    print( "\n----- Read Edm ------------------------------");
    Edm edm  = clienApp.readEdm(serviceUrl);
    print( "Read default EntityContainer: "  + edm.getDefaultEntityContainer().getName());
    print( "\n----- Read Feed ------------------------------");
    ODataFeed feed  = clienApp.readFeed(edm, serviceUrl, usedFormat,  "Manufacturers");
    print( "Read: "  + feed.getEntries().size()  +  " entries: ");
     for (ODataEntry entry : feed.getEntries()) {
      print( "##########");
      print( "Entry:\n"  + prettyPrint(entry));
      print( "##########");
    }
    print( "\n----- Read Entry ------------------------------");
    ODataEntry entry  = clienApp.readEntry(edm, serviceUrl, usedFormat,  "Manufacturers",  "'1'");
    print( "Single Entry:\n"  + prettyPrint(entry));
    Map < String,  Object > data  =  new HashMap < String,  Object >();
    data.put( "Id",  "123");
    data.put( "Name",  "MyCarManufacturer");
    data.put( "Founded",  new Date());
     //
    Map < String,  Object > address  =  new HashMap < String,  Object >();
    address.put( "Street",  "Main");
    address.put( "ZipCode",  "42421");
    address.put( "City",  "Fairy City");
    address.put( "Country",  "FarFarAway");
    data.put( "Address", address);
     //
    print( "\n----- Read Entry with $expand  ------------------------------");
    ODataEntry entryExpanded  = clienApp.readEntry(edm, serviceUrl, usedFormat,  "Manufacturers",  "'1'",  "Cars");
    print( "Single Entry with expanded Cars relation:\n"  + prettyPrint(entryExpanded));
     //
     //
    print( "\n----- Create Entry ------------------------------");
    ODataEntry createdEntry  = clienApp.createEntry(edm, serviceUrl, usedFormat,  "Manufacturers", data);
    print( "Created Entry:\n"  + prettyPrint(createdEntry));
    print( "\n----- Update Entry ------------------------------");
    data.put( "Name",  "MyCarManufacturer Renamed");
    address.put( "Street",  "Main Street");
    clienApp.updateEntry(edm, serviceUrl, usedFormat,  "Manufacturers",  "'123'", data);
    ODataEntry updatedEntry  = clienApp.readEntry(edm, serviceUrl, usedFormat,  "Manufacturers",  "'123'");
    print( "Updated Entry successfully:\n"  + prettyPrint(updatedEntry));
     //
    print( "\n----- Delete Entry ------------------------------");
    HttpStatusCodes statusCode  = clienApp.deleteEntry(serviceUrl,  "Manufacturers",  "'123'");
    print( "Deletion of Entry was successfully: "  + statusCode.getStatusCode()  +  ": "  + statusCode.getInfo());
     try {
      print( "\n----- Verify Delete Entry ------------------------------");
      clienApp.readEntry(edm, serviceUrl, usedFormat,  "Manufacturers",  "'123'");
    }  catch( Exception e) {
      print(e.getMessage());
    }
  }
   private  static  void print( String content) {
     System.out.println(content);
  }
   private  static  String prettyPrint(ODataEntry createdEntry) {
     return prettyPrint(createdEntry.getProperties(),  0);
  }
   private  static  String prettyPrint(Map < String,  Object > properties,  int level) {
     StringBuilder b  =  new  StringBuilder();
    Set <Entry < String,  Object >> entries  = properties.entrySet();
     for (Entry < String,  Object > entry : entries) {
      intend(b, level);
      b.append(entry.getKey()).append( ": ");
       Object value  = entry.getValue();
       if(value  instanceof Map) {
        value  = prettyPrint((Map < String,  Object >)value, level +1);
        b.append(value).append( "\n");
      }  else  if(value  instanceof Calendar) {
        Calendar cal  = (Calendar) value;
        value  = SimpleDateFormat.getInstance().format(cal.getTime());
        b.append(value).append( "\n");
      }  else  if(value  instanceof ODataDeltaFeed) {
        ODataDeltaFeed feed  = (ODataDeltaFeed) value;
        List <ODataEntry > inlineEntries  =  feed.getEntries();
        b.append( "{");
         for (ODataEntry oDataEntry : inlineEntries) {
          value  = prettyPrint((Map < String,  Object >)oDataEntry.getProperties(), level +1);
          b.append( "\n[\n").append(value).append( "\n],");
        }
        b.deleteCharAt(b.length() -1);
        intend(b, level);
        b.append( "}\n");
      }  else {
        b.append(value).append( "\n");
      }
    }
     // remove last line break
    b.deleteCharAt(b.length() -1);
     return b.toString();
  }
   private  static  void intend( StringBuilder builder,  int intendLevel) {
     for ( int i  =  0; i  < intendLevel; i ++) {
      builder.append( "  ");
    }
  }
   public  void generateSampleData( String serviceUrl)  throws MalformedURLException, IOException {
     String url  = serviceUrl.substring( 0, serviceUrl.lastIndexOf(SEPARATOR));
    HttpURLConnection connection  = initializeConnection(url  + INDEX, APPLICATION_FORM, HTTP_METHOD_POST);
     String content  =  "genSampleData=true";
    connection.getOutputStream().write(content.getBytes());
    print( "Generate response: "  + checkStatus(connection));
    connection.disconnect();
  }
   public Edm readEdm( String serviceUrl)  throws IOException, ODataException {
    InputStream content  = execute(serviceUrl  + SEPARATOR  + METADATA, APPLICATION_XML, HTTP_METHOD_GET);
     return EntityProvider.readMetadata(content,  false);
  }
   public ODataFeed readFeed(Edm edm,  String serviceUri,  String contentType,  String entitySetName)
       throws IOException, ODataException {
    EdmEntityContainer entityContainer  = edm.getDefaultEntityContainer();
     String absolutUri  = createUri(serviceUri, entitySetName,  null);
    InputStream content  = execute(absolutUri, contentType, HTTP_METHOD_GET);
     return EntityProvider.readFeed(contentType,
        entityContainer.getEntitySet(entitySetName),
        content,
        EntityProviderReadProperties.init().build());
  }
   public ODataEntry readEntry(Edm edm,  String serviceUri,  String contentType,  String entitySetName,  String keyValue)
       throws IOException, ODataException {
     return readEntry(edm, serviceUri, contentType, entitySetName, keyValue,  null);
  }
   public ODataEntry readEntry(Edm edm,  String serviceUri,  String contentType, 
       String entitySetName,  String keyValue,  String expandRelationName)
       throws IOException, ODataException {
     // working with the default entity container
    EdmEntityContainer entityContainer  = edm.getDefaultEntityContainer();
     // create absolute uri based on service uri, entity set name with its key property value and optional expanded relation name
     String absolutUri  = createUri(serviceUri, entitySetName, keyValue, expandRelationName);
    InputStream content  = execute(absolutUri, contentType, HTTP_METHOD_GET);
     return EntityProvider.readEntry(contentType,
        entityContainer.getEntitySet(entitySetName),
        content,
        EntityProviderReadProperties.init().build());
  }
   private InputStream logRawContent( String prefix, InputStream content,  String postfix)  throws IOException {
     if(PRINT_RAW_CONTENT) {
       byte[] buffer  = streamToArray(content);
      print(prefix  +  new  String(buffer)  + postfix);
       return  new ByteArrayInputStream(buffer);
    }
     return content;
  }
   private  byte[] streamToArray(InputStream stream)  throws IOException {
     byte[] result  =  new  byte[ 0];
     byte[] tmp  =  new  byte[ 8192];
     int readCount  = stream.read(tmp);
     while(readCount  >=  0) {
       byte[] innerTmp  =  new  byte[result.length  + readCount];
       System.arraycopy(result,  0, innerTmp,  0, result.length);
       System.arraycopy(tmp,  0, innerTmp, result.length, readCount);
      result  = innerTmp;
      readCount  = stream.read(tmp);
    }
    stream.close();
     return result;
  }
   public ODataEntry createEntry(Edm edm,  String serviceUri,  String contentType, 
       String entitySetName, Map < String,  Object > data)  throws  Exception {
     String absolutUri  = createUri(serviceUri, entitySetName,  null);
     return writeEntity(edm, absolutUri, entitySetName, data, contentType, HTTP_METHOD_POST);
  }
   public  void updateEntry(Edm edm,  String serviceUri,  String contentType,  String entitySetName, 
       String id, Map < String,  Object > data)  throws  Exception {
     String absolutUri  = createUri(serviceUri, entitySetName, id);
    writeEntity(edm, absolutUri, entitySetName, data, contentType, HTTP_METHOD_PUT);
  }
   public HttpStatusCodes deleteEntry( String serviceUri,  String entityName,  String id)  throws IOException {
     String absolutUri  = createUri(serviceUri, entityName, id);
    HttpURLConnection connection  = connect(absolutUri, APPLICATION_XML, HTTP_METHOD_DELETE);
     return HttpStatusCodes.fromStatusCode(connection.getResponseCode());
  }
   private ODataEntry writeEntity(Edm edm,  String absolutUri,  String entitySetName, 
      Map < String,  Object > data,  String contentType,  String httpMethod) 
       throws EdmException, MalformedURLException, IOException, EntityProviderException, URISyntaxException {
    HttpURLConnection connection  = initializeConnection(absolutUri, contentType, httpMethod);
    EdmEntityContainer entityContainer  = edm.getDefaultEntityContainer();
    EdmEntitySet entitySet  = entityContainer.getEntitySet(entitySetName);
    URI rootUri  =  new URI(entitySetName);
    EntityProviderWriteProperties properties  = EntityProviderWriteProperties.serviceRoot(rootUri).build();
     // serialize data into ODataResponse object
    ODataResponse response  = EntityProvider.writeEntry(contentType, entitySet, data, properties);
     // get (http) entity which is for default Olingo implementation an InputStream
     Object entity  = response.getEntity();
     if (entity  instanceof InputStream) {
       byte[] buffer  = streamToArray((InputStream) entity);
       // just for logging
       String content  =  new  String(buffer);
      print(httpMethod  +  " request on uri '"  + absolutUri  +  "' with content:\n  "  + content  +  "\n");
       //
      connection.getOutputStream().write(buffer);
    }
     // if a entity is created (via POST request) the response body contains the new created entity
    ODataEntry entry  =  null;
    HttpStatusCodes statusCode  = HttpStatusCodes.fromStatusCode(connection.getResponseCode());
     if(statusCode  == HttpStatusCodes.CREATED) {
       // get the content as InputStream and de-serialize it into an ODataEntry object
      InputStream content  = connection.getInputStream();
      content  = logRawContent(httpMethod  +  " request on uri '"  + absolutUri  +  "' with content:\n  ", content,  "\n");
      entry  = EntityProvider.readEntry(contentType,
          entitySet, content, EntityProviderReadProperties.init().build());
    }
     //
    connection.disconnect();
     return entry;
  }
   private HttpStatusCodes checkStatus(HttpURLConnection connection)  throws IOException {
    HttpStatusCodes httpStatusCode  = HttpStatusCodes.fromStatusCode(connection.getResponseCode());
     if ( 400  <= httpStatusCode.getStatusCode()  && httpStatusCode.getStatusCode()  <=  599) {
       throw  new  RuntimeException( "Http Connection failed with status "  + httpStatusCode.getStatusCode()  +  " "  + httpStatusCode.toString());
    }
     return httpStatusCode;
  }
   private  String createUri( String serviceUri,  String entitySetName,  String id) {
     return createUri(serviceUri, entitySetName, id,  null);
  }
   private  String createUri( String serviceUri,  String entitySetName,  String id,  String expand) {
     final  StringBuilder absolutUri  =  new  StringBuilder(serviceUri).append(SEPARATOR).append(entitySetName);
     if(id  !=  null) {
      absolutUri.append( "(").append(id).append( ")");
    }
     if(expand  !=  null) {
      absolutUri.append( "/?$expand=").append(expand);
    }
     return absolutUri.toString();
  }
   private InputStream execute( String relativeUri,  String contentType,  String httpMethod)  throws IOException {
    HttpURLConnection connection  = initializeConnection(relativeUri, contentType, httpMethod);
    connection.connect();
    checkStatus(connection);
    InputStream content  = connection.getInputStream();
    content  = logRawContent(httpMethod  +  " request on uri '"  + relativeUri  +  "' with content:\n  ", content,  "\n");
     return content;
  }
   private HttpURLConnection connect( String relativeUri,  String contentType,  String httpMethod)  throws IOException {
    HttpURLConnection connection  = initializeConnection(relativeUri, contentType, httpMethod);
    connection.connect();
    checkStatus(connection);
     return connection;
  }
   private HttpURLConnection initializeConnection( String absolutUri,  String contentType,  String httpMethod)
       throws MalformedURLException, IOException {
    URL url  =  new URL(absolutUri);
    HttpURLConnection connection  = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod(httpMethod);
    connection.setRequestProperty(HTTP_HEADER_ACCEPT, contentType);
     if(HTTP_METHOD_POST.equals(httpMethod)  || HTTP_METHOD_PUT.equals(httpMethod)) {
      connection.setDoOutput( true);
      connection.setRequestProperty(HTTP_HEADER_CONTENT_TYPE, contentType);
    }
     return connection;
  }
}
 

基于OData请求处理插件,还有个data plugin也有和Olingo clien一样的实现,但data plugin是一个人写的,目前还有很多bug,不支持中文,返回OData协议定义的报文体excle不一定能解析.所以支持apache 的Olingo client吧.

SoStraw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java -Apache Olingo-.7z
05-06
Apache Olingo 是个 Java 库，用来实现 Open Data Protocol (OData)。 Apache Olingo 包括服务客户端和 OData 服务器方面。当前支持 OData 2.0 ，未来会支持 OData 4.0。Apache Olingo 扩展部分支持 JPA 持久性或者注释 bean 类。
SAP OData编程指南
cnmik42448的专栏
06-18 2419
OData(Open Data Protocol)协议是一个开放的工业标准，用于定义RESTFul API的设计和使用。我的文章标题前加上SAP的前缀，只是为了表明这篇文章介绍的是Jerry在SAP项目开发中使用到ODat...
apache olingo_Apache Olingo现在是一个顶级项目
danpu0978的博客
05-14 309
apache olingo 阿帕奇软件基金会 （ Apache Software Foundation）最近宣布， 阿帕奇·奥林戈（Apache Olingo ）从阿帕奇孵化器（Apache Incubator）毕业，成为一个顶级项目，这表明该项目的社区和产品已在ASF的精英制流程和原则下得到了很好的管理。 Apache Olingo是OData（开放数据协议）标准的开放源代码，通用Jav...
java 调用odata,如何使用Olingo或SDL OData Framework在Java中使用OData4服务
weixin_30844301的博客
02-17 616
I need to consume an OData4 service from Java and based on the list of frameworks on the OData website the two choices are Olingo or the SDL Odata Framework. My problem is that the documentation for ...
Java restful之使用Apache olingo库来将JPA操作自动转化为RESTful
任何技能都是从模仿开始，逐步升华。
02-02 6524
Apache Olingo 是个 Java 库，用来实现 Open Data Protocol (OData)。 Apache Olingo 包括服务客户端和 OData 服务器方面。当前支持 OData 2.0 ，未来会支持 OData 4.0。Apache Olingo 扩展部分支持 JPA 持久性或者注释 bean 类。The Open Data Protocol (OData) 是个 web 协议，为了增强各种网页应用程序之间的数据兼容性，微软公司启动了一项旨在推广网页程序数据库格式标准化的开源数据
odata初探01
zjck1995的专栏
09-28 1222
servletservlet 结构如下图 在olingo中，我们需要添加在xml文件中添加如下代码<servlet> <servlet-name>ODataServiceServlet</servlet-name> <servlet-class>org.apache.olingo.odata2.core.servlet.ODataServlet</servlet-class>
Apache Olingo现在是一个顶级项目
danpu0978的博客
04-20 664
阿帕奇软件基金会 （ Apache Software Foundation）最近宣布， 阿帕奇·奥林戈（Apache Olingo ）从阿帕奇孵化器（Apache Incubator）毕业，成为一个顶级项目，这表明该项目的社区和产品已在ASF的精英管理流程和原则下得到了很好的管理。 Apache Olingo是OData（开放数据协议）标准的开放源代码，通用Java客户端和服务器库实现，...
搭建java库Olingo实现的OData项目实例
So straw?
10-17 4971
本技术文章原文:http://user.qzone.qq.com/974816077/2
java odata_如何捕获Olingo Client OdataV4 Java所发出的请求报文?
weixin_42452301的博客
02-16 271
### 问题描述Olingo Odata Client 会对 OdataServer 发出一些Request,其中包含实体查询、实体增删改,以及Action、Function的调用，当然这些请求也会以Batch的形式进行组装请求,我想捕获这些请求体结构，类似于通常在PostMan中测试的那样。我的求助问题来源于其请求代码的封装实在太好，无法接触到其发送请求的代码。，，也不知道去哪里查询到相关的ap...
OPC CLIENT使用手册
10-11
关于OPC CLIENT 使用手册的说明文档，请参考。
olingo实例代码
02-02
Apache Olingo 是个 Java 库，用来实现 Open Data Protocol (OData)。 Apache Olingo 包括服务客户端和 OData 服务器方面。当前支持 OData 2.0 ，未来会支持 OData 4.0。Apache Olingo 扩展部分支持 JPA 持久性或者注释 bean 类。The Open Data Protocol (OData) 是个 web 协议，为了增强各种网页应用程序之间的数据兼容性，微软公司启动了一项旨在推广网页程序数据库格式标准化的开源数据协议（OData）计划，于此同时，他们还发 布了一款适用于OData协议的开发工具，以方便网页程序开发者们使用。
olingo
03-26
Apache Olingo是实现开放数据协议（OData）的Java库。 Apache Olingo服务于OData的客户端和服务器方面。 它当前支持OData 2.0，并支持OData 4.0（测试版）。 后者是该协议的OASIS版本：OASIS开放数据协议（OData）TC。 Olingo for OData 2.0的扩展部分包含其他功能，例如对JPA持久性或带注释的Bean类的支持。https://mirrors.tuna.tsinghua.edu.cn/apache/olingo/odata2/2.0.11/
olingo-jpa-processor-v4:通过提供JPA元数据和OData元数据之间的映射，生成查询并支持实体操作，JPA处理器填补了Olingo V4与数据库之间的空白。
05-13
描述 如果将用于对象关系映射，则JPA处理器应填补与数据库之间的空白。 在当前状态下，JPA处理器提供以下支持： 从JPA元数据生成OData元数据。 通过将Get请求转换为Criteria Builder查询来处理它们。 支持实体操纵。 可以在“ 找到更多详细信息。 要求 JPA处理器至少需要Java版本 。 当前版本随附Olingo 4.7.1。 如果要更新有关Olingo的更改，请订阅Olingos。 即使如此，只要支持 ，也不推荐使用JPA实现，必须指出，所有测试都是使用。 如果您有任何问题，例如创建一个 ，但没有保证可以解决，因为Hibernate与EclipseLink相比“实现”了一些JPA接口。 下载及安装 JPA处理器是Maven项目的集合。 要使用它，您需要克隆存储库，导入项目并声明仅依赖于元数据生成： < dependency> < grou
实例化代码
11-11
实现动态效果的实例化代码 比较直观的再现
VisualSVN Client安装使用手册
10-15
VisualSVN是一种开源的版本控制软件，主要由VisualSVN Client和VisualSVN Server构成，本文档主要对客户端的安装和使用进行说明，以便开发人员尽快掌握使用VisualSVN进行源代码管理。
Kepware使用教程—OPC Quick Client具体使用
08-14
Kepware使用教程—OPC Quick Client具体使用 ；希望对初入Kepware的朋友有很好的帮助
nacos go client 使用Demo
06-27
go client Demo，附带了一些科学上网下载的开源库，给需要的小伙伴使用。 使用方法：解压之后，拷贝到%GOPATH%下即可，其中github.com/ 下是开源库，包括alibaba-cloud-sdk-go 等开源库，需要的小伙伴可以直接下载...
INFORMATICA CLIENT的使用
01-08
软件中各个组件的用法介绍，还有部分学习笔记及问题的处理
vulfocus靶场名称: apache-cve_2021_41773/apache-cve_2021_42013
最新发布
没有故事
04-19 446
Apache HTTP Server 2.4.49、2.4.50版本对路径规范化所做的更改中存在一个路径穿越漏洞，攻击者可利用该漏洞读取到Web目录外的其他文件，如系统配置文件、网站源码等，甚至在特定情况下，攻击者可构造恶意请求执行命令，控制服务器。目录遍历：GET /icons/.%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd。1:get：在url后面加上。远程代码执行：bp抓包。
gui61850client使用
01-23
gui61850client的使用可以帮助用户轻松地对智能电网系统进行监视和控制。用户可以通过该软件实时监测电网中的设备状态、电流、电压等参数，并根据需求对电网进行调整和控制。用户可以通过gui61850client对智能电网...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值