如何将twitter功能添加到我的struts2应用程序

我开发了struts2 web应用程序，现在我想让人们从他们的twitter帐户登录，所以我需要在我的正常登录按钮下放置一个名为“使用twitter登录”的按钮。据我所知，我已经做了Facebook集成，我们需要先在twitter上创建应用程序，所以我做了，然后我不知道该做什么，请任何人指导我完成这些步骤

我真的不记得在twitter上注册应用程序的过程，但谷歌“使用twitter的单点登录（SSO）”

首先，您需要注册您的应用程序，在注册过程中，您将获得一个消费者密钥和一个消费者密钥（不确定这些是否是twitter术语）

然后，过程是使用这些凭据将用户发送到twitter，让用户登录，然后让twitter通过回调将控制权返回到您的应用程序。该回调将包含一个授权令牌，该令牌将授予对twitter服务的访问权，因此我们将在会话中保存该令牌

注册应用程序后，以下代码将执行登录，并允许您将字符串“hello！”发布到您的twitter帐户（假设应用程序具有此权限）

TwitterGrantAccess.java

package com.quaternion.demo.action.twitter;

import com.opensymphony.xwork2.ActionSupport;
import java.util.Map;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.apache.struts2.interceptor.SessionAware;
import org.scribe.builder.ServiceBuilder;
import org.scribe.builder.api.TwitterApi;
import org.scribe.model.Token;
import org.scribe.oauth.OAuthService;

@Results(value = {
    @Result(name = "success", location = "${authorizationURL}", type = "redirect"),
    @Result(name = "error", location = "/WEB-INF/content/error.jsp")
})
public class TwitterGrantAccess extends ActionSupport implements SessionAware {

    private Map<String, Object> session;
    private String authorizationURL = null;

    @Override
    public String execute() {
        //Twitter twitter = new TwitterFactory().getInstance();
        String consumer_key = "NOT_PUTTING_MY_KEY_ON_STACK_OVERFLOW!";
        String consumer_secret = "NOT_PUTTING_MY_CONSUMER_SECRET_ON_STACK_OVERFLOW!";

        OAuthService twitterService = new ServiceBuilder()
                .provider(TwitterApi.class)
                .apiKey(consumer_key)
                .apiSecret(consumer_secret)
                .callback("http://localhost:8080/demo/twitter/twitter-callback")
                .build();
        Token requestToken = twitterService.getRequestToken();
        authorizationURL = twitterService.getAuthorizationUrl(requestToken);
        session.put("twitterService", twitterService);
        session.put("requestToken", requestToken);
        return SUCCESS;
    }

    public String getAuthorizationURL() {
        return this.authorizationURL;
    }

    @Override
    public void setSession(Map<String, Object> map) {
        this.session = map;
    }
}

package com.quaternion.demo.action.twitter；
导入com.opensymphony.xwork2.ActionSupport；
导入java.util.Map；
导入org.apache.struts2.convention.annotation.Result；
导入org.apache.struts2.convention.annotation.Results；
导入org.apache.struts2.interceptor.SessionAware；
导入org.scribe.builder.ServiceBuilder；
导入org.scribe.builder.api.TwitterApi；
导入org.scribe.model.Token；
导入org.scribe.oauth.OAuthService；
@结果（值={
@结果（name=“success”，location=“${authorizationURL}”，type=“redirect”），
@结果（name=“error”，location=“/WEB-INF/content/error.jsp”）
})
公共类TwitterGrantAccess扩展ActionSupport实现SessionAware{
私人Map会议；
私有字符串授权URL=null；
@凌驾
公共字符串execute（）{
//Twitter=new TwitterFactory（）.getInstance（）；
String consumer_key=“不将我的_key放在_堆栈_溢出上！”；
String consumer\u secret=“不将我的消费者\u secret\u放在\u堆栈\u溢出上！”；
OAuthService twitterService=新ServiceBuilder（）
.provider（TwitterApi.class）
.apiKey（消费者密钥）
.apiSecret（消费者机密）
.callback（“http://localhost:8080/demo/twitter/twitter-回拨“）
.build（）；
Token requestToken=twitterService.getRequestToken（）；
authorizationURL=twitterService.getAuthorizationUrl（requestToken）；
会话.put（“twitterService”，twitterService）；
session.put（“requestToken”，requestToken）；
回归成功；
}
公共字符串getAuthorizationURL（）{
返回此.authorizationURL；
}
@凌驾
公共无效设置会话（映射）{
this.session=map；
}
}

twitter调用的回调（您不会以用户身份调用此回调）。。。 TwitterCallback.java

package com.quaternion.demo.action.twitter;



import com.opensymphony.xwork2.ActionSupport;
import java.util.Map;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.apache.struts2.interceptor.SessionAware;
import org.scribe.model.Token;
import org.scribe.model.Verifier;
import org.scribe.oauth.OAuthService;

@Results(value = {
    @Result(name = "success", location = "/WEB-INF/content/twitter/twitter-callback-success.jsp"),
    @Result(name = "error", location = "/WEB-INF/content/twitter/twitter-callback-error.jsp")
})
public class TwitterCallback extends ActionSupport implements SessionAware {

    private Map<String, Object> session;
    private String key;
    private String secret;
    //returned from twitter
    private String oauth_token;
    private String oauth_verifier;

    @Override
    public String execute() {
        if (session.containsKey("accessToken") && session.get("accessToken") != null) {
            return SUCCESS; //accessToken already exists!
        }
        Token requestToken = (Token) session.get("requestToken");
        if (objectToken == null) {
            super.addActionError("requestToken is null");
            return ERROR;
        }
        OAuthService twitterService = (OAuthService) session.get("twitterService");
        System.out.println(requestToken.toString());
        System.out.println(this.getOauth_verifier());
        //Token accessToken = twitter.getOAuthAccessToken(requestToken, this.getOauth_verifier());
        Token accessToken = twitterService.getAccessToken(requestToken, new Verifier(this.getOauth_verifier()));
        session.put("accessToken", accessToken);
        this.setKey(accessToken.getToken()); //just to see something happen
        this.setSecret(accessToken.getSecret());//just to see something happen
        return SUCCESS;
    }

    @Override
    public void setSession(Map<String, Object> map) {
        this.session = map;
    }

    /**
     * @return the key
     */
    public String getKey() {
        return key;
    }

    /**
     * @param key the key to set
     */
    public void setKey(String key) {
        this.key = key;
    }

    public String getSecret() {
        return secret;
    }

    public void setSecret(String secret) {
        this.secret = secret;
    }

    public String getOauth_token() {
        return oauth_token;
    }

    /**
     * @param oauth_token the oauth_token to set
     */
    public void setOauth_token(String oauth_token) {
        this.oauth_token = oauth_token;
    }

    public String getOauth_verifier() {
        return oauth_verifier;
    }


    public void setOauth_verifier(String oauth_verifier) {
        this.oauth_verifier = oauth_verifier;
    }
}

//Posts the string "hello!" to the users twitter feed then redirects to
//ken_mcwilliams twitter url, because that is the account I will be
//logging into... change you your own account during development 

package com.quaternion.demo.action.twitter;

import com.opensymphony.xwork2.ActionSupport;
import java.util.Map;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.apache.struts2.interceptor.SessionAware;
import org.scribe.model.OAuthRequest;
import org.scribe.model.Response;
import org.scribe.model.Token;
import org.scribe.model.Verb;
import org.scribe.oauth.OAuthService;

@Results({
    @Result(name = "success", location = "https://twitter.com/#!/ken_mcwilliams", type = "redirect")
})
public class Tweet extends ActionSupport implements SessionAware {

    private Map<String, Object> session;
    private String status;

    @Override
    public String execute() {
        Token accessToken = (Token) session.get("accessToken");
        OAuthService twitterService = (OAuthService) session.get("twitterService");
        String url = "http://api.twitter.com/1/statuses/update.json?status=";
        String twitterStatus;
        if (status == null || status.isEmpty() == true) {
            twitterStatus = "hello!";
        }else{
            twitterStatus = status;
        }

        OAuthRequest request = new OAuthRequest(Verb.POST, url + twitterStatus);
        twitterService.signRequest(accessToken, request); // the access token from step 4
        Response response = request.send();
        return SUCCESS;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getStatus() {
        return this.status;
    }

    @Override
    public void setSession(Map<String, Object> map) {
        session = map;
    }
}

package com.quaternion.demo.action.twitter；
导入com.opensymphony.xwork2.ActionSupport；
导入java.util.Map；
导入org.apache.struts2.convention.annotation.Result；
导入org.apache.struts2.convention.annotation.Results；
导入org.apache.struts2.interceptor.SessionAware；
导入org.scribe.model.Token；
导入org.scribe.model.Verifier；
导入org.scribe.oauth.OAuthService；
@结果（值={
@结果（name=“success”，location=“/WEB-INF/content/twitter/twitter callback success.jsp”），
@结果（name=“error”，location=“/WEB-INF/content/twitter/twitter callback error.jsp”）
})
公共类TwitterCallback扩展ActionSupport实现SessionAware{
私人Map会议；
私钥；
私人字符串秘密；
//从twitter返回
私有字符串oauth_令牌；
私有字符串oauth_校验器；
@凌驾
公共字符串execute（）{
if（session.containsKey（“accessToken”）&session.get（“accessToken”）！=null）{
return SUCCESS；//accessToken已经存在！
}
令牌requestToken=（令牌）会话.get（“requestToken”）；
if（objectToken==null）{
super.addActionError（“requestToken为空”）；
返回误差；
}
OAuthService twitterService=（OAuthService）session.get（“twitterService”）；
System.out.println（requestToken.toString（））；
System.out.println（this.getOauth_verifier（））；
//Token accessToken=twitter.getOAuthAccessToken（requestToken，this.getOauth_verifier（））；
Token accessToken=twitterService.getAccessToken（requestToken，新验证器（this.getOauth_Verifier（））；
session.put（“accessToken”，accessToken）；
this.setKey（accessToken.getToken（））；//只是想看看发生了什么
this.setSecret（accessToken.getSecret（））；//只是想看看发生了什么
回归成功；
}
@凌驾
公共无效设置会话（映射）{
this.session=map；
}
/**
*@把钥匙还给我
*/
公共字符串getKey（）{
返回键；
}
/**
*@param key要设置的键
*/
公共无效设置键（字符串键）{
this.key=key；
}
公共字符串getSecret（）{
归还秘密；
}
公共无效设置机密（字符串机密）{
这个秘密；
}
公共字符串getOauth_token（）{
返回oauth_令牌；
}
/**
*@param oauth_token要设置的oauth_token
*/
public void setOauth_令牌（字符串oauth_令牌）{
this.oauth_令牌=oauth_令牌；
}
公共字符串getOauth_验证器（）{
返回oauth_校验器；
}
公共无效setOauth_验证器（字符串oauth_验证器）{
this.oauth_验证器=oauth_验证器；
}
}

完成此操作后，您的应用程序现在可以使用API，让我们