Java FeedFetcherCache类代码示例

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
private SyndFeed getFeed(String url) {
  FeedFetcherCache feedCache = HashMapFeedInfoCache.getInstance();
  try {
    HttpClientFeedFetcher httpClientFeedFetcher = new HttpClientFeedFetcher(feedCache);
    httpClientFeedFetcher.setConnectTimeout(5000);
    httpClientFeedFetcher.setReadTimeout(5000);
    return httpClientFeedFetcher.retrieveFeed(userAgent, new URL(url));
  } catch (IOException | FeedException | FetcherException e) {
    throw new RuntimeException(e);
  }
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
@Test
public void test() throws Exception {
    FeedFetcherCache cache = HashMapFeedInfoCache.getInstance();
    FeedFetcher fetcher = new HttpURLFeedFetcher(cache);
    SyndFeed feed = fetcher.retrieveFeed(new URL("https://www.w3.org/blog/news/feed/atom"));

    assertEquals("W3C News", feed.getTitle());
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
/**
 * Test events fired when there is a cache in use
 *
 */
public void testFetchEventsWithCache() {
    final FeedFetcherCache feedInfoCache = new HashMapFeedInfoCache();
    final FeedFetcher feedFetcher = getFeedFetcher(feedInfoCache);
    final FetcherEventListenerImpl listener = new FetcherEventListenerImpl();
    feedFetcher.addFetcherEventListener(listener);
    try {
        SyndFeed feed = feedFetcher.retrieveFeed(new URL("http://localhost:" + testPort + "/rome/FetcherTestServlet/"));
        assertNotNull(feed);
        assertTrue(listener.polled);
        assertTrue(listener.retrieved);
        assertFalse(listener.unchanged);
        listener.reset();

        // Since the feed is cached, the second request should not
        // actually retrieve the feed
        feed = feedFetcher.retrieveFeed(new URL("http://localhost:" + testPort + "/rome/FetcherTestServlet/"));
        assertNotNull(feed);
        assertTrue(listener.polled);
        assertFalse(listener.retrieved);
        assertTrue(listener.unchanged);
        listener.reset();

        // now simulate getting the feed after it has changed
        feed = feedFetcher.retrieveFeed(new URL("http://localhost:" + testPort + "/rome/FetcherTestServlet?refreshfeed=TRUE"));
        assertNotNull(feed);
        assertTrue(listener.polled);
        assertTrue(listener.retrieved);
        assertFalse(listener.unchanged);
        listener.reset();
    } catch (final Exception e) {
        e.printStackTrace();
        fail(e.getMessage());
    }
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
public void testDeltaEncoding() {
    final FeedFetcherCache feedInfoCache = new HashMapFeedInfoCache();
    final FeedFetcher feedFetcher = getFeedFetcher(feedInfoCache);
    try {
        feedFetcher.setUsingDeltaEncoding(true);

        // first retrieval should just grab the default feed
        final SyndFeed feed1 = feedFetcher.retrieveFeed(new URL("http://localhost:" + testPort
                + "/rome/FetcherTestServlet?deltaencode=TRUE&refreshfeed=TRUE"));
        assertNotNull(feed1);
        assertEquals("atom_1.0.feed.title", feed1.getTitle());
        assertEquals(2, feed1.getEntries().size());
        SyndEntry entry1 = feed1.getEntries().get(0);
        assertEquals("atom_1.0.feed.entry[0].title", entry1.getTitle());

        // second retrieval should get only the new item
        /*
         * This is breaking with Rome 0.5 ??
         */
        final SyndFeed feed2 = feedFetcher.retrieveFeed(new URL("http://localhost:" + testPort
                + "/rome/FetcherTestServlet?deltaencode=TRUE&refreshfeed=TRUE"));
        assertNotNull(feed2);
        assertEquals(FetcherTestServlet.DELTA_FEED_TITLE, feed2.getTitle());
        assertEquals(3, feed2.getEntries().size());
        entry1 = feed2.getEntries().get(0);
        assertEquals(FetcherTestServlet.DELTA_FEED_ENTRY_TITLE, entry1.getTitle());

        final SyndEntry entry2 = feed2.getEntries().get(1);
        assertEquals("atom_1.0.feed.entry[0].title", entry2.getTitle());

    } catch (final Exception e) {
        e.printStackTrace();
        fail(e.getMessage());
    }
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
public DeltaFeedInfoCache(final FeedFetcherCache backingCache) {
    this.backingCache = backingCache;
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
public Subscriptions(final FeedFetcherCache cache, final Requester requester, final String callbackPrefix, final SubDAO dao) {
    this.cache = cache;
    this.requester = requester;
    this.callbackPrefix = callbackPrefix;
    this.dao = dao;
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
/**
 * @param cache the cache to set
 */
public void setCache(final FeedFetcherCache cache) {
    this.cache = cache;
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
@Override
protected FeedFetcher getFeedFetcher(final FeedFetcherCache cache) {
    return new HttpURLFeedFetcher(cache);
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
@Override
protected FeedFetcher getFeedFetcher(final FeedFetcherCache cache) {
    return new HttpClientFeedFetcher(cache);
}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
public static void main(final String[] args) {

        boolean ok = false;

        if (args.length >= 2) {

            try {

                final String outputType = args[0];

                final SyndFeed feed = new SyndFeedImpl();
                feed.setFeedType(outputType);

                feed.setTitle("Aggregated Feed");
                feed.setDescription("Anonymous Aggregated Feed");
                feed.setAuthor("anonymous");
                feed.setLink("http://www.anonymous.com");

                final List<SyndEntry> entries = new ArrayList<SyndEntry>();
                feed.setEntries(entries);

                final FeedFetcherCache feedInfoCache = HashMapFeedInfoCache.getInstance();
                final FeedFetcher feedFetcher = new HttpURLFeedFetcher(feedInfoCache);

                for (int i = 1; i < args.length; i++) {
                    final URL inputUrl = new URL(args[i]);
                    final SyndFeed inFeed = feedFetcher.retrieveFeed(inputUrl);
                    entries.addAll(inFeed.getEntries());
                }

                final SyndFeedOutput output = new SyndFeedOutput();
                output.output(feed, new PrintWriter(System.out));

                ok = true;

            } catch (final Exception ex) {
                System.out.println("ERROR: " + ex.getMessage());
                ex.printStackTrace();
            }

        }

        if (!ok) {
            System.out.println();
            System.out.println("FeedAggregator aggregates different feeds into a single one.");
            System.out.println("The first parameter must be the feed type for the aggregated feed.");
            System.out.println(" [valid values are: rss_0.9, rss_0.91, rss_0.92, rss_0.93, ]");
            System.out.println(" [                  rss_0.94, rss_1.0, rss_2.0 & atom_0.3  ]");
            System.out.println("The second to last parameters are the URLs of feeds to aggregate.");
            System.out.println();
        }
    }
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
public static void main(final String[] args) {

        boolean ok = false;

        if (args.length == 1) {

            try {
                final URL feedUrl = new URL(args[0]);
                final FeedFetcherCache feedInfoCache = HashMapFeedInfoCache.getInstance();
                final FeedFetcher fetcher = new HttpURLFeedFetcher(feedInfoCache);

                final FetcherEventListenerImpl listener = new FetcherEventListenerImpl();

                fetcher.addFetcherEventListener(listener);

                System.err.println("Retrieving feed " + feedUrl);
                // Retrieve the feed.
                // We will get a Feed Polled Event and then a
                // Feed Retrieved event (assuming the feed is valid)
                final SyndFeed feed = fetcher.retrieveFeed(feedUrl);

                System.err.println(feedUrl + " retrieved");
                System.err.println(feedUrl + " has a title: " + feed.getTitle() + " and contains " + feed.getEntries().size() + " entries.");
                // We will now retrieve the feed again. If the feed is unmodified
                // and the server supports conditional gets, we will get a "Feed
                // Unchanged" event after the Feed Polled event
                System.err.println("Polling " + feedUrl + " again to test conditional get support.");
                fetcher.retrieveFeed(feedUrl);
                System.err.println("If a \"Feed Unchanged\" event fired then the server supports conditional gets.");

                ok = true;

            } catch (final Exception ex) {
                System.out.println("ERROR: " + ex.getMessage());
                ex.printStackTrace();
            }

        }

        if (!ok) {
            System.out.println();
            System.out.println("FeedReader reads and prints any RSS/Atom feed type.");
            System.out.println("The first parameter must be the URL of the feed to read.");
            System.out.println();
        }

    }
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
public RSSFetcherRunner(final String rssUrl, final Port out) throws MalformedURLException {
    this.feedUrl = new URL(rssUrl);
    final FeedFetcherCache feedInfoCache = HashMapFeedInfoCache.getInstance();
    this.fetcher = new HttpURLFeedFetcher(feedInfoCache);

    final FetcherListener listener = new RSSEventListener(out);

    this.fetcher.addFetcherEventListener(listener);


}
 

import com.rometools.fetcher.impl.FeedFetcherCache; //导入依赖的package包/类
protected abstract FeedFetcher getFeedFetcher(FeedFetcherCache cache);