소셜네트워크 트위터 API 개발 #2 Open API , Twitter API , SNS

"트위터 API 개발"

[연결 포스팅]

2012/03/19 - [개발노트/JAVA] - 오픈API 시작하며 #1 OpenAPI , JSON , XML , HTTP , OAuth

 

[필독]

1) 연결되는 포스팅입니다. 꼭 이전 포스팅을 참고하세요.
2) OAuth 와 SNS API 대해 기본적인 지식이 필요합니다.
3) 포함된 소스는 참고용이며, 그대로 사용할 경우 오류가 발생합니다. 직접 필요한 부분을 개발하세요.
- 직접 개발해야 할 부분은 임의적으로 주석처리 하였습니다.
4) 시간이 없어 급정리해서 올리는 글입니다. 부족한 부분이 많습니다. 이점 참고하세요.
5) 원문 그대로 사용하는 것을 방지하기 위해 소스파일은 제공하기 않습니다. 꼭 소스를 분석후 직접 개발하세요.

 

 

http://twitter.com/

소셜네트워크 대명사 트위터에서 제공되는 API를 이용하여 특화된 트위터를 개발해보자.

우선 트위터 API는 OAuth 2.0 인증방식을 사용한다. 

그래서 OAuth 프로그램을 먼저 개발하고, 트위터 프로그램을 개발하겠다.

1. 트위터 어플리케이션 생성

https://dev.twitter.com/

우선 트위터 개발자 공간에서 애플리케이션을 생성하자. 생성법은 생략한다.

OAuth settings 항목에 다양한 값들이 있는 데 이것을 이용하여 OAuth 인증을 받을 수 있다.

아래의 클래스 파일들을 개발하고 맨 아래의 내용을 참조하여 트위터를 구현하자.

 2. HTTP Classes

Http 클래스는 인증처리 및 클라이언트와 SNS의 통신에서 주로 사용한다.
1장에서 설명한 아파치 HTTP 컴포넌트 라이브러리를 사용하여 개발하였다.

  

/*
* SnsAuthHttp.java 2011.11.15
*
* Copyright (c) 2010, MEI By Seok Kyun. Choi. (최석균)
* http://syaku.tistory.com
*
* GNU Lesser General Public License
* http://www.gnu.org/licenses/lgpl.html
*/
package com.syaku.modules.snsauth;

import java.util.*;

import org.apache.http.client.HttpClient;
import org.apache.http.HttpEntity;
import org.apache.http.util.EntityUtils;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.DefaultHttpClient;

import oauth.signpost.*;

import org.apache.log4j.Logger;
import org.apache.commons.lang.*;

public class SnsAuthHttp {
  private Logger log = Logger.getLogger(SnsAuthHttp.class);

  // OAuth 인증으로 GET 요청
  public String getHttpGet(String http_url,OAuthConsumer consumerHttp) throws Exception {
    HttpGet http_get = new HttpGet(http_url);

    if (consumerHttp != null) {
      consumerHttp.sign(http_get);
    }

    HttpClient httpclient = new DefaultHttpClient();
    HttpResponse response = httpclient.execute(http_get);

    HttpEntity entity = response.getEntity();
    return EntityUtils.toString(entity); // String return
  }

  // HTTP GET 요청
  public String getHttpGet(String http_url) throws Exception {
    HttpGet http_get = new HttpGet(http_url);
    HttpClient httpclient = new DefaultHttpClient();
    HttpResponse response = httpclient.execute(http_get);

    HttpEntity entity = response.getEntity();
    return EntityUtils.toString(entity);
  }

  // HTTP POST 요청
  public String getHttpPost(String http_url,UrlEncodedFormEntity formentity,OAuthConsumer consumerHttp) throws Exception {
    HttpPost http_post = new HttpPost(http_url);
    http_post.setEntity(formentity);

    if (consumerHttp != null) {
      consumerHttp.sign(http_post);
    }

    HttpClient httpclient = new DefaultHttpClient();
    HttpResponse response = httpclient.execute(http_post);

    HttpEntity entity = response.getEntity();

    return EntityUtils.toString(entity);
  }

}

3. OAuth Classes

 

OAuth 클래스는 다른 SNS 에서도 사용됩니다.
1장에서 소개한 oauth signpost 라이브러리를 사용하였다.

 

/*
* SnsOAuthAPI.java 2011.10.20
*
* Copyright (c) 2010, MEI By Seok Kyun. Choi. (최석균)
* http://syaku.tistory.com
*
* GNU Lesser General Public License
* http://www.gnu.org/licenses/lgpl.html
*/
package com.syaku.modules.snsauth;

import java.util.*;

import oauth.signpost.*;
import oauth.signpost.basic.*;
import oauth.signpost.exception.*;
import oauth.signpost.commonshttp.*;

import org.apache.log4j.Logger;
import org.apache.commons.lang.*;

public class SnsOAuthAPI {
  private Logger log = Logger.getLogger(SnsOAuthAPI.class);

  private String request_token_url;
  public void setRequest_token_url(String request_token_url) {this.request_token_url = request_token_url; }
  private String authorize_url;
  public void setAuthorize_url(String authorize_url) {this.authorize_url = authorize_url; }
  private String access_token_url;
  public void setAccess_token_url(String access_token_url) {this.access_token_url = access_token_url; }

  private String consumer_key;
  public void setConsumer_key(String consumer_key) {this.consumer_key = consumer_key; }
  private String consumer_secret;
  public void setConsumer_secret(String consumer_secret) {this.consumer_secret = consumer_secret; }
  private String callback;
  public void setCallback(String callback) {this.callback = callback; }

  public OAuthProvider provider;
  public OAuthConsumer consumer;

  public void getInstance() throws Exception{
    log.debug("[MEI SnsOAuthAPI getInstance]");
    this.provider = new CommonsHttpOAuthProvider(this.request_token_url, this.access_token_url, this.authorize_url);
    this.consumer = new CommonsHttpOAuthConsumer(this.consumer_key, this.consumer_secret);

    log.debug("[MEI SnsOAuthAPI] consumer_key : " + consumer_key);
    log.debug("[MEI SnsOAuthAPI] consumer_secret : " + consumer_secret);
   }

  // request 토큰 요청
  public String getRequestToken() throws Exception{
    log.debug("[MEI SnsOAuthAPI] callback : " + callback);
    
    // 서비스 url 얻음
    String oauth_url = provider.retrieveRequestToken(consumer, callback);

    log.debug("[MEI SnsOAuthAPI] token : " + consumer.getToken());
    log.debug("[MEI SnsOAuthAPI] token_secret : " + consumer.getTokenSecret());
    log.debug("[MEI SnsOAuthAPI] oauth_url : " + oauth_url);

    return oauth_url;
  }

  // access 토큰 요청
  public void getAccessToken(String oauth_verifier) throws Exception {
    log.debug("[MEI SnsOAuthAPI getAccessToken]");
    provider.retrieveAccessToken(consumer, oauth_verifier);
    log.debug("[MEI SnsOAuthAPI] access_token : " + consumer.getToken());
    log.debug("[MEI SnsOAuthAPI] access_token_secret : " + consumer.getTokenSecret());
  }

  // 재인증 처리
  public void getAcceptToken(String access_token,String access_tokensecret) throws Exception {
    log.debug("[MEI SnsOAuthAPI getAcceptToken]");
    consumer.setTokenWithSecret(access_token, access_tokensecret);
    log.debug("[MEI SnsOAuthAPI] access_token : " + consumer.getToken());
    log.debug("[MEI SnsOAuthAPI] access_token_secret : " + consumer.getTokenSecret());
  }

}

 

 4. Twitter API Classes

/*
* TwitterAPI.java 2011.10.20
*
* Copyright (c) 2010, MEI By Seok Kyun. Choi. (최석균)
* http://syaku.tistory.com
*
* GNU Lesser General Public License
* http://www.gnu.org/licenses/lgpl.html
*/
package com.syaku.modules.snsauth;

import java.util.*;

import org.apache.log4j.Logger;
import org.apache.commons.lang.*;
import org.apache.commons.collections.*;

import oauth.signpost.*;
import oauth.signpost.basic.*;
import oauth.signpost.exception.*;

import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;

import net.sf.json.*;

//import org.apache.commons.codec.binary.Base64;
//import org.apache.commons.codec.digest.DigestUtils;

//import javax.servlet.*;
//import javax.servlet.http.*;
//import com.opensymphony.xwork2.*;
//import org.apache.struts2.ServletActionContext;

//import com.ibatis.sqlmap.client.SqlMapClient;
//import org.apache.commons.configuration.Configuration;
//import com.syaku.config.*;
//import com.syaku.common.*;
//import com.syaku.core.*;
//import com.syaku.util.*;

public class TwitterAPI extends SnsOAuthAPI {
  //private Logger log = Logger.getLogger(TwitterAPI.class);
  //public SqlMapClient sqlMap = SqlMapConfig.getSqlMapInstance(); // iBatis (디비 프레임워크)
  //public final Configuration MODULE_CONFIG = SyakuConfig.getInstance("com/syaku/modules/snsauth/info.properties"); // 모듈 정보 호출

  public HttpServletRequest request = ServletActionContext.getRequest();
  public HttpServletResponse response = ServletActionContext.getResponse();
  public HttpSession session = request.getSession();

  //private SnsAuthObject mSnsAuthObject = new SnsAuthObject(); // DAO , SNS Object
  //private SnsAuthStored mSnsAuthStored = new SnsAuthStored(); // 세션 및 쿠키 저장 클래스
  private SnsAuthHttp mSnsAuthHttp = new SnsAuthHttp();

  // 트위터 회원정보
  private String uid,user_id,nickname,profile_cover,post_send;
  public String getUid() { return this.uid; } // 고유 ID (숫자)
  public String getUser_id() { return this.user_id; } // 사용자 ID (영문)
  public String getNickname() { return this.nickname; } // 별명
  public String getProfile_cover() { return this.profile_cover; } // 프로필 사진
  public void setPost_send(String post_send) { this.post_send = post_send; }
  public String getPost_send() { return this.post_send; } // 글 전송 여부

  final String API_URL = "http://api.twitter.com/1";
  final String SNS_NAME = "TWITTER";
  final int TEXT_LENGTH = 140; // 글 내용 길이

  public TwitterAPI() { // 클래스를 호출할때 아래의 값들을 변수로 받는것이 유동성에 좋음.
    this.setRequest_token_url( "Request token URL" );
    this.setAuthorize_url( "Authorize URL" );
    this.setAccess_token_url( "Access token URL" );
    this.setConsumer_key( "Consumer key" );
    this.setConsumer_secret( "Consumer secret" );
    this.setCallback( "Callback URL" );
  }


  // 트위터 싱크처리
  public void getSignIn() throws Exception {

    try {
    String token = "쿠키에 저장된 access_token 을 읽어옴";
   
    if (StringUtils.isNotEmpty(token)) { // token 있을 경우

      if (mSnsAuthStored.getAuthSessValid(this.SNS_NAME) == false) { // 세션이 없을 경우

        // 세션이 없다면 디비에서 정보 조회 (아래의 소스는 직접 구현하기)
        //Map mapSch = new HashMap();
        //mapSch.put("name",this.SNS_NAME);
        //mapSch.put("token",token);
        //SnsAuthBean objSns = (SnsAuthBean) mSnsAuthObject.getSnsAuthView(mapSch);

        if (objSns != null) {
          // access token
          String access_token = objSns.getAccess_token();
          String access_token_secret = objSns.getAccess_token_secret();
          this.getInstance(); // SnsOAuthAPI.getInstance
          getAuthSync(access_token,access_token_secret); // access 인증요청
        }

      }

      if (mSnsAuthStored.getAuthSessValid(this.SNS_NAME) == true) { // 세션이 있을 경우
        Map<String,String> mapUser = this.getUserInfo(); // 트위터 계정 정보
        //mSnsAuthStored.setUserInfo(this.SNS_NAME,mapUser); 세션갱신
      }

      mSnsAuthStored.setAuthCookie(token); // 쿠키 갱신

    } else { // token 없을 경우

      //mSnsAuthStored.getSessRemove(this.SNS_NAME); 세션 삭제 (쿠키는 없고 세션이 살아 있을 경우 대비)
    }


    } catch (Exception e) {
      //log.error(e.toString());
      //mSnsAuthStored.getSessRemove(this.SNS_NAME);
    }

  }
 
  // 트위터 인증 접속
  // ParameterUtils param -> request.getParameter("oauth_token")
  public String getAccess(ParameterUtils param) throws Exception{
    String auth_url = null; //트위터에서 받은 auth_url (인증요청 url)
    String oauth_token = param.value("oauth_token"); // 트위터에서 받은 request parameter
    String oauth_verifier = param.value("oauth_verifier"); // 트위터에서 받은 request parameter

    //String token = mSnsAuthStored.getAuthCookie(); // 쿠키에 저장된 계정
    String access_token = null;
    String access_token_secret = null;

    Map mapSch = new HashMap();
   
    // oauth_token 없을 경우
    if (StringUtils.isEmpty(oauth_token)) {
     
      // 쿠키값이 있을 경우
      if (StringUtils.isNotEmpty(token)) {
       
        // 디비에 저장된 트위터 정보 조회
        //mapSch.clear();
        //mapSch.put("name",this.SNS_NAME);
        //mapSch.put("token",token);
        //SnsAuthBean objSns = (SnsAuthBean) mSnsAuthObject.getSnsAuthView(mapSch);

        if (objSns != null) {
          // access token
          access_token = objSns.getAccess_token();
          access_token_secret = objSns.getAccess_token_secret();
        }
       
        //mSnsAuthStored.setAuthCookie(token); // 쿠키갱신
      }

      this.getInstance(); // SnsOAuthAPI.getInstance
      if (access_token != null && access_token_secret != null) {

        // access token 을 이용하여 재인증 처리
        getAuthSync(access_token,access_token_secret);
        auth_url = "SUCCESS";

      } else {
        //mSnsAuthStored.getSessRemove(this.SNS_NAME); 세션 삭제
        auth_url = getRequestToken(); // 트위터 인증 url 요청
        //mSnsAuthStored.setSessCreate(this.SNS_NAME,this.consumer,this.provider); // oauth_token 세션에 인증 consumer , provider 필수로 저장

      }

    } else {// oauth_token 있을 경우


      try {
        //sqlMap.startTransaction(); // iBatis 용
       
        if (StringUtils.isEmpty(token)) { // 쿠키 토큰이 없을 경우
          // 임의의 토큰 생성 및 토큰 디비저장.
          //token = DigestUtils.sha256Hex(DigestUtils.sha256("syaku" + DateUtils.date("yyyyMMddHHmmss") + "me"));
        }

        // OAuth 를 이용하여 트위터에 인증요청
        getSuccess(oauth_token,oauth_verifier);
        access_token = consumer.getToken();
        access_token_secret = consumer.getTokenSecret();
       
        // 트위터 싱크처리
        getAuthSync(access_token,access_token_secret);
        Map<String,String> mapUser = this.getUserInfo(); // 트위터 계정 정보

        /* 디비에 저장할 정보를 기록
        String uid = this.uid;
        String ip = request.getRemoteAddr();
        String user_agent = request.getHeader("User-Agent");

        mSnsAuthObject.getSnsAuthMainResetUpdate(token); // 여러 SNS 에서 트위터를 대표 sns 설정

        SnsAuthBean snsauthbean = new SnsAuthBean();
        snsauthbean.setToken(token); // 쿠키 ID
        snsauthbean.setName(this.SNS_NAME); // SNS 명 (TWITTER)
        snsauthbean.setAccess_token(access_token); // 트위터 access token
        snsauthbean.setAccess_token_secret(access_token_secret); // 트위터 access_token_secret
        snsauthbean.setMain("Y"); // 대표 SNS 설정
        snsauthbean.setPost_send("Y"); // 글 전송 여부
        snsauthbean.setUid(uid); // 트위터 고유ID
        snsauthbean.setReg_date(DateUtils.date("yyyyMMddHHmmss")); // 등록일
        snsauthbean.setIp(ip); //등록자 아이피
        snsauthbean.setUser_agent(user_agent); // 헤더 USER_AGENT
        mSnsAuthObject.getSnsAuthInsert(snsauthbean); // 디비에 저장

        mSnsAuthStored.setAuthCookie(token); // 쿠키 갱신
        mSnsAuthStored.setUserInfo(this.SNS_NAME,mapUser); // 트위터 계정 정보 세션에 저장
        mSnsAuthStored.setSessClean(oauth_token); // oauth_token 인증을 위해 생성한 세션 삭제
        */

        auth_url = "SUCCESS";

        //sqlMap.commitTransaction(); // iBatis 용

      } catch (Exception e) {
        //mSnsAuthStored.getSessRemove(this.SNS_NAME); // 세션삭제
        //log.error(e.toString()); // 로그 출력

      } finally {
        //sqlMap.endTransaction(); // iBatis 용
      }

    }

    return auth_url; // 트위터에서 제공하는 URL
  }

  // 트위터 인증 완료
  public void getSuccess(String oauth_token,String oauth_verifier) throws Exception{
    // getAccess에서 생성된 세션
    this.consumer = (OAuthConsumer) session.getAttribute("_MEI_" + oauth_token + "_CR");
    this.provider = (OAuthProvider) session.getAttribute("_MEI_" + oauth_token + "_PR");

    String request_token = (String) session.getAttribute("_MEI_" + oauth_token + "_REQT");
    String request_tokensecret = (String) session.getAttribute("_MEI_" + oauth_token + "_REQTS");

    if (StringUtils.isNotEmpty(request_token) && StringUtils.isNotEmpty(request_token)) {
      // access 토큰 요청
      getAccessToken(oauth_verifier);
    }
  }

  // 트위터 재인증 처리
  public void getAuthSync(String access_token,String access_tokensecret) throws Exception{

    if (access_token != null && access_tokensecret != null) {
      getAcceptToken(access_token,access_tokensecret);
      //mSnsAuthStored.setAuthSess(this.SNS_NAME,this.consumer); consumer 세션에 저장 : 인증완료 후 consumer 는 트위터 요청에서 자주 필요하므로 세션에 저장한다.
    }

  }

  // 트위터 계정 정보 가져오기
  public Map<String,String> getUserInfo() throws Exception {
    this.uid = null;
    this.user_id = null;
    this.nickname = null;
    this.profile_cover = null;

    //OAuthConsumer sess_consumer = (OAuthConsumer) mSnsAuthStored.getAuthSess(this.SNS_NAME); // 세션에 저장된 consumer

    //Map<String,String> mapSS = (Map<String,String>) mSnsAuthStored.getUserInfo(this.SNS_NAME); 이전에 세션에 저장된 트위터 계정
    Map<String,String> mapRet = new HashMap();
   
    if (MapUtils.isNotEmpty(mapSS)) {
      this.uid = mapSS.get("uid");
      this.user_id = mapSS.get("user_id");
      this.nickname = mapSS.get("nickname");
      this.profile_cover = mapSS.get("profile_cover");
    } else {
      // 트위터에서 계정 정호 가져옴
      String result = mSnsAuthHttp.getHttpGet(API_URL + "/account/verify_credentials.json",sess_consumer);

      try {
        // json 라이브러리 이용함.
        JSONObject objJson = JSONObject.fromObject(result);

        String uid = objJson.getString("id"); // uid
        String user_id = objJson.getString("screen_name");
        String nickname = objJson.getString("name");
        String profile_cover = objJson.getString("profile_image_url");

        // 정보 기록
        this.uid = uid;
        this.user_id = user_id;
        this.nickname = nickname;
        this.profile_cover = profile_cover;

      } catch (Exception e) {
        //mSnsAuthStored.getSessRemove(this.SNS_NAME);
        getException(result);
      }

    }

    if (this.user_id != null || this.nickname != null || this.profile_cover != null) {
      mapRet.put("uid",this.uid);
      mapRet.put("user_id",this.user_id);
      mapRet.put("nickname",this.nickname);
      mapRet.put("profile_cover",this.profile_cover);
    }

    return mapRet;

  }

  // 트위터 글쓰기
  // getPost 메소드를 호출 후 msg_id 받아 글 내용과 같이 디비에 저장하자. msg_id 는 글을 나중에 삭제할때 필요하다.
  // https://dev.twitter.com/docs/api/1/post/statuses/update 참고하여 필요한 정보를 구현하세요.
  public String getPost(Map map) throws Exception {
    //OAuthConsumer sess_consumer = (OAuthConsumer) mSnsAuthStored.getAuthSess(this.SNS_NAME);

    String msg_id = null;
    String message = (String) map.get("message");
    String parent_msg_id = (String) map.get("parent_msg_id");
    String url = (String) map.get("url");

    List<NameValuePair> formparams = new ArrayList<NameValuePair>();
    if (StringUtils.isNotEmpty(url)) {
      //SnsConnection sns = new SnsConnection();
      //url = sns.bitly_com(url); // url 줄이기 (bitly.com 이용)
      message = "#syaku " + url + " " + message; // 글내용 정리 ( #은 태그)
    } else {
      message = "#syaku " + message; // 글내용 정리 ( #은 태그)
    }

    //message = FnUtils.getCutString(message,TEXT_LENGTH,""); // 글자길이 자르기

    formparams.add(new BasicNameValuePair("status", message));

    // 리트윗 구현할 때 사용.
    if (StringUtils.isNotEmpty(parent_msg_id)) { // 부모글 msg_id
      formparams.add(new BasicNameValuePair("in_reply_to_status_id", parent_msg_id));
    }

    UrlEncodedFormEntity formentity = new UrlEncodedFormEntity(formparams, "UTF-8");

    String result = mSnsAuthHttp.getHttpPost(API_URL + "/statuses/update.json",formentity,sess_consumer);
    log.debug("[MEI TWITTER POST result]" + result);

    JSONObject objJson = JSONObject.fromObject(result);
    try {
      msg_id = objJson.getString("id");
    } catch (Exception e) {
      getException(result);
    }

    log.debug("[MEI TWITTER POST ID]" + msg_id);
    return msg_id;
  }

  // 트위터 글 삭제
  public void getDelete(String msg_id) throws Exception {
    //OAuthConsumer sess_consumer = (OAuthConsumer) mSnsAuthStored.getAuthSess(this.SNS_NAME);

   String result = mSnsAuthHttp.getHttpPost(API_URL + "/statuses/destroy/" + msg_id + ".json",null,sess_consumer);
    JSONObject objJson = JSONObject.fromObject(result);
    getException(result);
  }

  // result json 익셉션 출력
  public void getException(String json) throws Exception {
    String msg_text = null;
    JSONObject objJson = JSONObject.fromObject(json);
    try {
      msg_text = objJson.getString("error");
    } catch (Exception e) {
    }

    if (StringUtils.isNotEmpty(msg_text)) {
      log.debug("TWITTER : " + msg_text);
      //throw new Exception("TWITTER : " + msg_text);
    }

  }

}

 5. 트위터 프로그램

 

트위터 뷰(JSP)단의 필요한 UI 항목은 아래와 같다. JSP와 자바스크립트를 적절하게 혼합하여 구현하면 된다.

 

- 트위터에 등록된 글 목록
- 글을 삭제하는 삭제버튼
- 글을 등록하는 쓰기 폼
- 트위터에 로그인 하거나 로그아웃하는 버튼

 

1단계. 세션이나 쿠키 존재를 파악하여 트위터 계정을 연결한다.

 

// 객체생성
TwitterAPI twitter = new TwitterAPI();

String token = ID 쿠키가져오기;

if token 존재할 경우 {
  twitter.getSignIn(); // 트위터 연결

  twitter.getUid(); // 고유 아이디 (숫자)
  twitter.getUser_id(); // 유동 아이디 (영문)
  twitter.getNickname(); // 별명
  twitter.getProfile_cover(); // 절대경로의 프로필 사진
}

 

2단계. 트위터 글 목록

트위터에 연결하여 글을 가져오는 것이 아니라, 글을 쓸때마다 자신의 디비에 저장한다. 꼭 글 id도 함께 저장하여야 한다.
[참고] 프로필 사진는 id를 이용해 img 태그로 가져오면 된다.

 

3단계. 트위터 로그인 , 로그아웃

1단계 트위터 계정이 연결되지 않을 경우 UI 상에서 로그인 버튼을 노출시켜 로그인을 유도한다.
로그인 버튼을 누를 경우 새 창이 뜬다. 이때 추가 화면(JSP)이 필요하고
본 화면의 URL이 트위터 애플리케이션(OAuth settings)의 콜백 URL이 되어야한다.
그래서 트위터 서버에 거친 후 다시 돌아오게 되고, oauth_token 파라미터 값을 얻을 수 있다.

TwitterAPI twitter = new TwitterAPI();
// 연결이 되지 않을 경우 (토큰이나 세션이 없을경우) auth_url 를 리턴받는 다.
auth_url = twitter.getAccess(request);

if (auth_url 값이 있을 경우) {
 auth_url 페이지로 이동하게 함
} else {
 새 창을 닫고 부모 페이지를 새로고침함.
}

 

로그아웃은 쿠키와 세션에서 트위터 정보를 삭제하면 된다.

 

4단계. 글 쓰기 , 글삭제

TwitterAPI twitter = new TwitterAPI();

 

// https://dev.twitter.com/docs/api/1/post/statuses/update 참고하여 필요한 정보를 구현하세요.

Map map = new HashMap();
map.put("message","글 내용");
//map.put("parent_msg_id","리트윗 msg_id");

String msg_id = twitter.getPost(map);

트위터에 정상적으로 등록되면 msg_id 와 message 를 서버 디비에 저장한다.

 

// 글 삭제
twitter.getDelete(msg_id);