//Creamos una instancia de Twitter, usemos el TwitterFactory , trabajamos con la version de Twitter4j 2.3.1
this.twitter = new TwitterFactory().getInstance();
// Las 2 llaves que nos da Twitter al registrar la aplicacion, estas son fundamentales las
// usaremos mucho, se deben almacenar en la base de datos
this.twitter.setOAuthConsumer("consumer_key", "consumer_secret");
//Solicitamos un REQUEST TOKEN, este objeto solo se debe crear una sola vez.
this.requestToken = twitter.getOAuthRequestToken();
//Obtenemos el URL, este url lo podemos presentar en JSF con un link y nos enviara a la página
// de twitter, daremos permiso a nuestra aplicacion
// y obtendremos el pin que usaremos a continuacion.
final String url = this.requestToken.getAuthorizationURL();

//El objeto AccessToken, este objeto lo usaremos constantemente, cada vez que querramos 
//comunicarnos con Twitter, en este caso para validar nuestro
// RequesToken y obtener 2 llaves mas, que son las definitivas y las que nos permitiran 
//publicar, hasta el momento no hemos terminado
this.accessToken = this.twitter.getOAuthAccessToken(this.requestToken, "PIN");
//Si despues de esto todo sale bien (sin TwitterExceptions) tendremos ya acceso a los TOKENS, 
// son 2 cadenas que almacenaremos en nuestra base de datos
// y usaremos posteriormente para publicar nuestros tweets o obtener algo de informacion de nuestra cuenta.
//El token
log.debug("New Token {"+this.accessToken.getToken());
//El Token Secret
log.debug("New Secret Token {"+this.accessToken.getTokenSecret());
 //Testing send twitter, WORKS !!
//Si queremos probar que todo funciona, seteamos el ACCESS TOKEN que validamos anteriormente con el objeto Twitter.
 this.twitter.setOAuthAccessToken(accessToken);
// Publicamos algo para comprobar.
 this.twitter.updateStatus("test accessToken");
//Guardamos los dos tokens en la base de datos.

//Para poder acceder a nuestra cuenta, postear o obtener algo de info, recuperamos nuestros
// 4 datos principales, creamos un ACCESSTOKEN seteando en el // constructor el Token y el Secret Token validos
final AccessToken accessToken = new AccessToken("Token", "Secret Token");
//Creamos una nueva instancia de Twitter y creamos una nueva instancia de autorizacion 
// con nuestras otras 2 llaves Consumer y el objeto creado 
// anteriormente ACCESS TOKEN 
Twitter twitter = new TwitterFactory().getOAuthAuthorizedInstance("Consumer Key", "Consumer Secret", accessToken);
//Una vez echo esto, ya tenemos el objeto Twitter cargado y listo para ser usado, podemos probar las credenciales.
twitter.verifyCredentials();

public final class MyViewFeedRssView extends AbstractRssFeedView {
 
    /**
     * En el caso de los RSS debemos crear el Channel, parece la gente de Spring se olvido de hacerlo por nosotros, ojo
     * con llenar bien el Channel.
     */
    @Override
    protected Channel newFeed() {
        final Channel channel = new Channel("rss_2.0");
        channel.setPubDate(new Date());
        channel.setDescription("RSS Description");
        channel.setTitle("TITLE");
        channel.setLink("link");
        channel.setCopyright("2010");
        channel.setPubDate(new Date());
        return  channel;
    }
 
    /**
     * Build Feed Entries.
     */
    @SuppressWarnings("unchecked")
    @Override
    protected List buildFeedEntries(Map model, HttpServletRequest request,
            HttpServletResponse response) throws Exception {
         // Obtenemos las entradas que vienen en el modelo desde el Controller
        List contentList = (List) model.get("entries");
        // Creamos una lista de clase de Item, el objeto de ROME que refleja cada elemento del RSS
        List entries = new ArrayList(contentList.size());
        // Iteramos nuestras entradas del blog
        for (EntriesBlog content : contentList) {
                   final Item item = new Item();
            String date = String.format("%1$tY-%1$tm-%1$td", content.getPublicationDateTweet());
            item.setTitle(String.format("On %s, %s publish", date, content.getQuestionBean().getQuestionName()));
            item.setPubDate(content.getPublicationDateTweet());
            item.setLink("http://www.encuestame.org");
            entries.add(entry);
        }
        return entries;
    }
}

@Controller
public class RSSFeedController extends AbstractFeedController {
 
    /**
     * Build Feed Body.
     */
    private void buildTweetPollFeedBody(String username, Model model, HttpServletRequest request, User user){
         model.addAttribute("username", username);
         model.addAttribute("feedTitle", String.format(TWEET_POLL_FEED_TITLE, username));
         model.addAttribute("url", buildDomainWithRequest(request));
         //buscamos nuestras entradas de nuestro blog, por poner un ejemplo
         final List entries = getEntries(user.getUsername());
          // las guardamos en el modelo que pasaremos a la vista y usaremos mas adelante.
         model.addAttribute("entries", entries);
    }
 
    /**
     * Display RSS Feed.
     */
     // Utilizar REST es sencillo, solo debemos definir la variable entre llaves y llamarla con la anotacion @PathVariable
    @RequestMapping(value = "/feed/{username}/entries.rss", method = RequestMethod.GET)
    public String tweetPollRss(@PathVariable String username, Model model, HttpServletRequest request) {
       // Como queremos utilizar el mismo RSS para diferentes usuarios, buscamos nuestro usuario.
        final User user = getByUsername(username);
        if(user == null){
            //TODO: if null do something.
        }
        else{
             // Como somos muy ordenados creamos otro metodo.
            this.buildTweetPollFeedBody(username, model, request, user);
        }
        // Aqui regresaremos una cadena, que no es mas que el ID de nuestra VISTA del Bean RSS.
        return "rssFeedView";
    }
}