使用Java/App引擎向Blogger发出正确形式的API请求-错误401_Java_Google App Engine_Blogger_Google Api Java Client

使用Java/App引擎向Blogger发出正确形式的API请求-错误401

java google-app-engine

使用Java/App引擎向Blogger发出正确形式的API请求-错误401,java,google-app-engine,blogger,google-api-java-client,Java,Google App Engine,Blogger,Google Api Java Client,在调用Blogger api时，我遇到了为JAVA生成正确api语句的问题我已经通过谷歌云控制台测试了我的声明，它在我的代码中工作，但不工作。我正在使用谷歌应用程序引擎，并已被授权使用博客。授权还与运行Google App Engine的帐户相关任何想法都会有帮助。。周末我尝试了很多东西谢谢 Request GET https://www.googleapis.com/blogger/v3/blogs/7676001971884966148/posts?key= {YOUR_API_K

在调用Blogger api时，我遇到了为JAVA生成正确api语句的问题

我已经通过谷歌云控制台测试了我的声明，它在我的代码中工作，但不工作。我正在使用谷歌应用程序引擎，并已被授权使用博客。授权还与运行Google App Engine的帐户相关

任何想法都会有帮助。。周末我尝试了很多东西

谢谢

Request
GET https://www.googleapis.com/blogger/v3/blogs/7676001971884966148/posts?key=   {YOUR_API_KEY}

Authorization:  Bearer ya29.1.AADtN_Vd7lKj8Xy3KbZ1veJjjjv712Nc1erLY2dmAK3gorNilVd0652vnqrrovfuLfSKkQ
X-JavaScript-User-Agent:  Google APIs Explorer


Response
200 OK

- Show headers -

{
"kind": "blogger#postList",
"nextPageToken": "CgkIChjim-ftqygQhIKb6_zjqMNq",
"items": [
{
etc.....

我的代码

public class BloggerHandler
{

  public static final Logger log = Logger.getLogger(BloggerHandler.class.getName());

public void testCreds() throws Exception  {
   try{
   ArrayList<String> scopes = new ArrayList<String>();
    scopes.add("https://www.googleapis.com/auth/blogger");
    scopes.add("https://www.googleapis.com/auth/blogger.readonly");


    AppIdentityService appIdentity = AppIdentityServiceFactory.getAppIdentityService();
    AppIdentityService.GetAccessTokenResult accessToken = appIdentity.getAccessToken(scopes);
    // The token asserts the identity reported by appIdentity.getServiceAccountName()
    JSONObject request = new JSONObject();
   //request.put("maxPosts", "1");

   //request.put("view", "AUTHOR");

    log.info("request!!!" + request);

     URL url = new URL("https://www.googleapis.com/blogger/v3/blogs/7676001971884966148/posts?");
     log.info("URL:" + url);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setDoOutput(true);
    connection.setRequestMethod("GET");
    connection.addRequestProperty("Content-Type", "application/json");
    connection.addRequestProperty("Authorization", "OAuth" + accessToken.getAccessToken());

    log.info("Con!!" + connection);


    OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream());
    request.write(writer);
    writer.close();
     log.info("connection:" + connection.getResponseCode());
     if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
        // Note: Should check the content-encoding.
        JSONTokener response_tokens = new JSONTokener(connection.getInputStream());
        JSONObject response = new JSONObject(response_tokens);

        log.info("resp:" + response.get("title")); 




     } // end if 

     else {
        throw new Exception();
     }// end else

     } // end try

     catch (Exception e) {
    // Error handling elided.
    log.info("ex:" + e);


    }
// end catch



}// end void


}// end class

公共类BloggerHandler
{
公共静态最终记录器log=Logger.getLogger（BloggerHandler.class.getName（））；
public void testCreds（）引发异常{
试一试{
ArrayList范围=新的ArrayList（）；
作用域。添加（“https://www.googleapis.com/auth/blogger");
作用域。添加（“https://www.googleapis.com/auth/blogger.readonly");
appIdentity服务appIdentity=appIdentity服务工厂。GetAppIdentity服务（）；
AppIdentityService.GetAccessTokenResult accessToken=appIdentity.getAccessToken（作用域）；
//令牌断言appIdentity.getServiceAccountName（）报告的标识
JSONObject请求=新建JSONObject（）；
//请求。put（“maxPosts”、“1”）；
//请求。提交（“视图”、“作者”）；
log.info（“请求！！！”+请求）；
URL=新URL（“https://www.googleapis.com/blogger/v3/blogs/7676001971884966148/posts?");
log.info（“URL:+URL”）；
HttpURLConnection connection=（HttpURLConnection）url.openConnection（）；
connection.setDoOutput（真）；
connection.setRequestMethod（“GET”）；
addRequestProperty（“内容类型”、“应用程序/json”）；
addRequestProperty（“授权”、“OAuth”+accessToken.getAccessToken（））；
log.info（“Con！！”+连接）；
OutputStreamWriter writer=新的OutputStreamWriter（connection.getOutputStream（））；
请求。写（作者）；
writer.close（）；
log.info（“连接：+connection.getResponseCode（））；
if（connection.getResponseCode（）==HttpURLConnection.HTTP\u确定）{
//注意：应检查内容编码。
JSONTokener response_tokens=新的JSONTokener（connection.getInputStream（））；
JSONObject response=新的JSONObject（response_标记）；
log.info（“resp:+response.get”（“title”）；
}//如果结束，则结束
否则{
抛出新异常（）；
}//结束其他
}//结束尝试
捕获（例外e）{
//省略错误处理。
日志信息（“例如：+e”）；
}
//端接
}//端部空隙
}//末级

经过几个漫长的夜晚，我终于找到了从GAE项目访问Google Blogger API的方法

我做了一些关键的事情，可能会对你有所帮助

在您的Google Appe引擎项目中，确保它链接到Google API控制台。在GAE管理项目屏幕中，您应该看到一个谷歌API控制台项目编号：XX
在GoogleAPI云控制台中，确保您被授权使用Blogger（或任何您想要使用的云API）。创建一个项目（网站等）并复制它提供给您的API字符串

一旦你有了这个API字符串，下面的代码应该可以让你开始基本连接

下面的代码应该返回一个“200”连接，其中包含您试图访问的当前博客的统计信息。从这里您可以扩展API

//另一方面，我知道有一种方法可以从谷歌云读取API，因此它不必是代码的一部分。仍在处理该工作流

import java.util.logging.Logger;
import java.util.Arrays;
import com.google.api.client.googleapis.extensions.appengine.auth.oauth2.AppIdentityCredential;
import com.google.api.services.blogger.Blogger;
import com.google.api.services.blogger.Blogger.Blogs.GetByUrl;
import com.google.api.services.blogger.Blogger.Posts.List;
import com.google.api.services.blogger.BloggerScopes;
import com.google.api.services.blogger.model.Blog;
import com.google.api.services.blogger.model.Post;
import com.google.api.services.blogger.model.PostList;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.client.extensions.appengine.http.UrlFetchTransport;
import java.io.IOException;

public class BlogHandler
{
  public Blogger blogger = null;
  public Blog blog;
  public java.util.List<Post> posts;
  public static final Logger log = Logger.getLogger(EngineParseFeed.class.getName());
  static final String API_KEY = "{Your GOOGLE CLOUD API}";

  public BlogHandler() {}

  public void setupService () throws IOException {

    AppIdentityCredential credential = null;
    credential  = new AppIdentityCredential(Arrays.asList(BloggerScopes.BLOGGER)); // Add your scopes here
    this.blogger = new Blogger.Builder(new UrlFetchTransport(), new JacksonFactory(), credential).setApplicationName("trivalAPPName").build();
   }

   public void executeGetBlogByUrl (String url) throws IOException {
     GetByUrl request = blogger.blogs().getByUrl( url );
     this.blog = request.setKey(API_KEY).execute();
     log.info ("Blog" + this.blog);
   }

import java.util.logging.Logger；
导入java.util.array；
导入com.google.api.client.googleapis.extensions.appengine.auth.oauth2.AppIdentityCredential；
导入com.google.api.services.blogger.blogger；
导入com.google.api.services.blogger.blogger.Blogs.GetByUrl；
导入com.google.api.services.blogger.blogger.Posts.List；
导入com.google.api.services.blogger.BloggerScopes；
导入com.google.api.services.blogger.model.Blog；
导入com.google.api.services.blogger.model.Post；
导入com.google.api.services.blogger.model.PostList；
导入com.google.api.client.json.jackson2.JacksonFactory；
导入com.google.api.client.extensions.appengine.http.UrlFetchTransport；
导入java.io.IOException；
公共类BlogHandler
{
公共Blogger Blogger=null；
公共博客；
public java.util.List posts；
公共静态最终记录器log=Logger.getLogger（EngineParseFeed.class.getName（））；
静态最终字符串API_KEY=“{Your GOOGLE CLOUD API}”；
公共BlogHandler（）{}
公共void setupService（）引发IOException{
AppIdentityCredential凭证=null；
credential=new-AppIdentityCredential（Arrays.asList（BloggerScopes.BLOGGER））；//在此处添加您的作用域
this.blogger=new blogger.Builder（new urlfetchttransport（），new JacksonFactory（），credential）.setApplicationName（“trivalAPPName”）.build（）；
}
public void executeGetBlogByUrl（字符串url）引发IOException{
GetByUrl请求=blogger.blogs（）.GetByUrl（url）；
this.blog=request.setKey（API_KEY）.execute（）；
log.info（“Blog”+this.Blog）；
}

我一直在研究这个问题，我的结论是：

要请求博客或帖子，只要它们是公开的，你就不必进行身份验证，也就是说，这种请求不需要OAuth。但是，你必须识别你的应用程序，并使用APP_密钥来完成。正如这里所述，没有任何应用程序可以使用Blogger API，它必须经过授权，因此就是这个密钥需要

基于1，您不需要创建AppIdentityCredential。我只是将Builder的第三个参数设置为null。我尝试使用您的代码，但没有成功

我仍然有一个问题，可能和iamkhova的问题一样。我认为应用程序可以使用GAE应用程序的AppIdentityCredential对OAuth进行身份验证。但是你怎么能告诉google我的应用程序是我试图访问的博客的所有者呢？我想这就是获得401的原因。

我设法获得了它

public class BloggerServlet
   {
   private static final HttpTransport HTTP_TRANSPORT = new NetHttpTransport();
  private static final JsonFactory JSON_FACTORY = JacksonFactory.getDefaultInstance();   
  public static GoogleAuthorizationCodeFlow flow;

    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException
     {        
  DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();   
  Entity OAuthTokenEntity;
  OAuthProperties oauthProperties = new OAuthProperties();
   String OAuthAccessToken, OAuthRefreshToken;
  try
     { 
     OAuthTokenEntity = datastore.get(KeyFactory.createKey("OAuthTokenEntity","OA"));
     OAuthAccessToken = OAuthTokenEntity.getProperty("OAuthAccessToken").toString();
     OAuthRefreshToken = OAuthTokenEntity.getProperty("OAuthRefreshToken").toString();
     }
  catch(EntityNotFoundException e)
     {
     Collection<String> scopes = Arrays.asList(BloggerScopes.BLOGGER);
     flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY,
           CLIENT_ID, CLIENT_SECRET, scopes)
           .setAccessType("offline")
           .setApprovalPrompt("auto").build();
     String url = flow.newAuthorizationUrl()
            .setRedirectUri(OAuthCodeCallbackHandlerServlet.getOAuthCodeCallbackHandlerUrl(request))
            .build();
     response.sendRedirect("http://OAuthCodeCallbackHandlerServlet");
     return;
     }

  GoogleCredential credential = new GoogleCredential.Builder()
            .setTransport(HTTP_TRANSPORT)
            .setJsonFactory(JSON_FACTORY)
            .setClientSecrets(CLIENT_ID, CLIENT_SECRET)
            .build();

  credential.setAccessToken(OAuthAccessToken);
  credential.setRefreshToken(OAuthRefreshToken);

  Blogger blog = new Blogger.Builder(HTTP_TRANSPORT, JSON_FACTORY, credential)
     .setApplicationName("APP_NAME").setHttpRequestInitializer(credential).build();
  }
  }

public class OAuthCodeCallbackHandlerServlet
  {
   public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
   {
   String[] code = request.getParameterValues("code");

   GoogleTokenResponse tokenResponse = BloggerServlet.flow.newTokenRequest(code[0]).setRedirectUri(getOAuthCodeCallbackHandlerUrl(request)).execute();

   DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();    
   Entity OAuthTokenEntity = new Entity("OAuthTokenEntity","OA");
   OAuthTokenEntity.setProperty("OAuthAccessToken", tokenResponse.getAccessToken());
   OAuthTokenEntity.setProperty("OAuthRefreshToken",tokenResponse.getRefreshToken());
   datastore.put(OAuthTokenEntity);

   response.sendRedirect("http://BloggerServlet");
   }

public static String getOAuthCodeCallbackHandlerUrl(HttpServletRequest request) 
   {
   StringBuilder oauthURL = new StringBuilder();
   oauthURL.append(request.getScheme() + "://");
   oauthURL.append(request.getServerName());
   oauthURL.append(request.getServerPort() == 80 ? "" : ":" + request.getServerPort());
   oauthURL.append(request.getContextPath());
   oauthURL.append(URL_MAPPING);
   oauthURL.append(request.getPathInfo() == null ? "" : request.getPathInfo());  
   return oauthURL.toString(); 
   }
}