diff --git a/src/com/facebook/buck/java/AccumulateClassNames.java b/src/com/facebook/buck/java/AccumulateClassNames.java
index 84bfced..142bfad 100644
--- a/src/com/facebook/buck/java/AccumulateClassNames.java
+++ b/src/com/facebook/buck/java/AccumulateClassNames.java
@@ -25,29 +25,50 @@
 import com.facebook.buck.rules.BuildRuleType;
 import com.facebook.buck.rules.Buildable;
 import com.facebook.buck.rules.BuildableContext;
+import com.facebook.buck.rules.OnDiskBuildInfo;
 import com.facebook.buck.step.Step;
 import com.facebook.buck.step.fs.MkdirStep;
 import com.facebook.buck.step.fs.RmStep;
 import com.facebook.buck.util.BuckConstant;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+import com.google.common.base.Supplier;
+import com.google.common.base.Suppliers;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSortedMap;
 import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.hash.HashCode;
 
 import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.List;
 
+import javax.annotation.Nullable;
+
 /**
  * {@link Buildable} that writes the list of {@code .class} files found in a zip or directory to a
  * file.
  */
 public class AccumulateClassNames extends AbstractBuildable {
 
+  private static final Splitter CLASS_NAME_AND_HASH_SPLITTER = Splitter.on(
+      AccumulateClassNamesStep.CLASS_NAME_HASH_CODE_SEPARATOR);
+
   private final JavaLibraryRule javaLibraryRule;
   private final Path pathToOutputFile;
 
-  private AccumulateClassNames(BuildTarget buildTarget, JavaLibraryRule javaLibraryRule) {
+  /**
+   * This will contain the classes info discovered in the course of building this {@link Buildable}.
+   * This {@link Supplier} will be defined and determined after this buildable is built.
+   */
+  @VisibleForTesting
+  @Nullable
+  Supplier<ImmutableSortedMap<String, HashCode>> classNames;
+
+  @VisibleForTesting
+  AccumulateClassNames(BuildTarget buildTarget, JavaLibraryRule javaLibraryRule) {
     Preconditions.checkNotNull(buildTarget);
     this.javaLibraryRule = Preconditions.checkNotNull(javaLibraryRule);
     this.pathToOutputFile = Paths.get(
@@ -81,13 +102,47 @@
     // Make sure that the output directory exists for the output file.
     steps.add(new MkdirStep(pathToOutputFile.getParent()));
 
-    steps.add(new AccumulateClassNamesStep(
+    AccumulateClassNamesStep accumulateClassNamesStep = new AccumulateClassNamesStep(
         Paths.get(javaLibraryRule.getPathToOutputFile()),
-        Paths.get(getPathToOutputFile())));
+        Paths.get(getPathToOutputFile()));
+    classNames = accumulateClassNamesStep;
+    steps.add(accumulateClassNamesStep);
 
     return steps.build();
   }
 
+  public ImmutableSortedMap<String, HashCode> getClassNames() {
+    // TODO(mbolin): Assert that this Buildable has been built. Currently, there is no way to do
+    // that from a Buildable (but there is from an AbstractCachingBuildRule).
+    Preconditions.checkNotNull(classNames);
+    return classNames.get();
+  }
+
+  @Override
+  protected void initializeFromDisk(OnDiskBuildInfo onDiskBuildInfo) {
+    // Assign this.classNames when instantiating this Buildable when pulled from cache.
+
+    // Read the output file, which should now be in place because this rule was downloaded from
+    // cache.
+    List<String> lines;
+    try {
+      lines = onDiskBuildInfo.getOutputFileContentsByLine(this);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+
+    // Use the contents of the file to create the ImmutableSortedMap<String, HashCode>.
+    ImmutableSortedMap.Builder<String, HashCode> classNamesBuilder = ImmutableSortedMap.naturalOrder();
+    for (String line : lines) {
+      List<String> parts = CLASS_NAME_AND_HASH_SPLITTER.splitToList(line);
+      Preconditions.checkState(parts.size() == 2);
+      String key = parts.get(0);
+      HashCode value = HashCode.fromString(parts.get(1));
+      classNamesBuilder.put(key, value);
+    }
+    this.classNames = Suppliers.ofInstance(classNamesBuilder.build());
+  }
+
   public static Builder newAccumulateClassNamesBuilder(AbstractBuildRuleBuilderParams params) {
     return new Builder(params);
   }
diff --git a/src/com/facebook/buck/java/AccumulateClassNamesStep.java b/src/com/facebook/buck/java/AccumulateClassNamesStep.java
index fd1ccbc..e2e0cb5 100644
--- a/src/com/facebook/buck/java/AccumulateClassNamesStep.java
+++ b/src/com/facebook/buck/java/AccumulateClassNamesStep.java
@@ -25,6 +25,7 @@
 import com.facebook.buck.step.Step;
 import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
+import com.google.common.base.Supplier;
 import com.google.common.collect.ImmutableSortedMap;
 import com.google.common.collect.Iterables;
 import com.google.common.hash.HashCode;
@@ -39,11 +40,14 @@
 import java.util.Map;
 import java.util.Map.Entry;
 
+import javax.annotation.Nullable;
+
 /**
  * {@link Step} that takes a directory or zip of {@code .class} files and traverses it to get the
  * total set of {@code .class} files included by the directory or zip.
  */
-public class AccumulateClassNamesStep extends AbstractExecutionStep {
+public class AccumulateClassNamesStep extends AbstractExecutionStep
+    implements Supplier<ImmutableSortedMap<String, HashCode>> {
 
   /**
    * In the generated {@code classes.txt} file, each line will contain the path to a {@code .class}
@@ -61,6 +65,14 @@
   private final Path pathToJarOrClassesDirectory;
   private final Path whereClassNamesShouldBeWritten;
 
+  /**
+   * Map of names of {@code .class} files to hashes of their contents.
+   * <p>
+   * This is not set until this step is executed.
+   */
+  @Nullable
+  private ImmutableSortedMap<String, HashCode> classNames;
+
   public AccumulateClassNamesStep(Path pathToJarOrClassesDirectory,
       Path whereClassNamesShouldBeWritten) {
     super("get_class_names " + pathToJarOrClassesDirectory + " > " + whereClassNamesShouldBeWritten);
@@ -119,7 +131,15 @@
       return 1;
     }
 
+    this.classNames = classNames;
     return 0;
   }
 
+  @Override
+  public ImmutableSortedMap<String, HashCode> get() {
+    Preconditions.checkNotNull(classNames,
+        "Step must be executed successfully before invoking this method.");
+    return classNames;
+  }
+
 }
diff --git a/src/com/facebook/buck/rules/OnDiskBuildInfo.java b/src/com/facebook/buck/rules/OnDiskBuildInfo.java
index 06555d5..cc84282 100644
--- a/src/com/facebook/buck/rules/OnDiskBuildInfo.java
+++ b/src/com/facebook/buck/rules/OnDiskBuildInfo.java
@@ -21,7 +21,10 @@
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 
+import java.io.IOException;
 import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
 
 /**
  * Utility for reading the metadata associated with a build rule's output. This is metadata that
@@ -73,4 +76,16 @@
     return getValue(BuildInfo.METADATA_KEY_FOR_RULE_KEY_WITHOUT_DEPS)
         .transform(RuleKey.TO_RULE_KEY);
   }
+
+  /**
+   * Invokes the {@link Buildable#getPathToOutputFile()} method of the specified {@link Buildable},
+   * reads the file at the specified path, and returns the list of lines in the file.
+   */
+  public List<String> getOutputFileContentsByLine(Buildable buildable) throws IOException {
+    Preconditions.checkNotNull(buildable);
+    String pathToOutputFile = buildable.getPathToOutputFile();
+    Preconditions.checkNotNull(pathToOutputFile);
+    Path path = Paths.get(pathToOutputFile);
+    return projectFilesystem.readLines(path);
+  }
 }
diff --git a/test/com/facebook/buck/java/AccumulateClassNamesStepTest.java b/test/com/facebook/buck/java/AccumulateClassNamesStepTest.java
index 60de63a..3512cd0 100644
--- a/test/com/facebook/buck/java/AccumulateClassNamesStepTest.java
+++ b/test/com/facebook/buck/java/AccumulateClassNamesStepTest.java
@@ -23,6 +23,8 @@
 import com.facebook.buck.util.ProjectFilesystem;
 import com.google.common.base.Charsets;
 import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableSortedMap;
+import com.google.common.hash.HashCode;
 import com.google.common.io.Files;
 
 import org.junit.Rule;
@@ -80,6 +82,14 @@
             "com/example/Foo" + separator + SHA1_FOR_EMPTY_STRING,
             "com/example/subpackage/Baz" + separator + SHA1_FOR_EMPTY_STRING) + '\n',
         contents);
+    assertEquals(
+        "get() should return the class name/hash mappings.",
+        ImmutableSortedMap.of(
+          "com/example/Bar", HashCode.fromString(SHA1_FOR_EMPTY_STRING),
+          "com/example/Foo", HashCode.fromString(SHA1_FOR_EMPTY_STRING),
+          "com/example/subpackage/Baz", HashCode.fromString(SHA1_FOR_EMPTY_STRING)
+        ),
+        accumulateClassNamesStep.get());
   }
 
   @Test
@@ -115,5 +125,21 @@
             "com/example/Foo" + separator + SHA1_FOR_EMPTY_STRING,
             "com/example/subpackage/Baz" + separator + SHA1_FOR_EMPTY_STRING) + '\n',
         contents);
+    assertEquals(
+        "get() should return the class name/hash mappings.",
+        ImmutableSortedMap.of(
+          "com/example/Bar", HashCode.fromString(SHA1_FOR_EMPTY_STRING),
+          "com/example/Foo", HashCode.fromString(SHA1_FOR_EMPTY_STRING),
+          "com/example/subpackage/Baz", HashCode.fromString(SHA1_FOR_EMPTY_STRING)
+        ),
+        accumulateClassNamesStep.get());
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void testGetClassesBeforeExecuteThrowsException() {
+    AccumulateClassNamesStep accumulateClassNamesStep = new AccumulateClassNamesStep(
+        Paths.get("pathToJarOrClassesDirectory"),
+        Paths.get("whereClassNamesShouldBeWritten"));
+    accumulateClassNamesStep.get();
   }
 }
diff --git a/test/com/facebook/buck/java/AccumulateClassNamesTest.java b/test/com/facebook/buck/java/AccumulateClassNamesTest.java
index f04c5d2..d9987a6 100644
--- a/test/com/facebook/buck/java/AccumulateClassNamesTest.java
+++ b/test/com/facebook/buck/java/AccumulateClassNamesTest.java
@@ -16,7 +16,9 @@
 
 package com.facebook.buck.java;
 
+import static org.easymock.EasyMock.expect;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 
 import com.facebook.buck.model.BuildTarget;
 import com.facebook.buck.rules.AbstractBuildRuleBuilderParams;
@@ -26,13 +28,16 @@
 import com.facebook.buck.rules.BuildRuleType;
 import com.facebook.buck.rules.BuildableContext;
 import com.facebook.buck.rules.FakeAbstractBuildRuleBuilderParams;
+import com.facebook.buck.rules.OnDiskBuildInfo;
 import com.facebook.buck.step.ExecutionContext;
 import com.facebook.buck.step.Step;
 import com.facebook.buck.step.TestExecutionContext;
 import com.facebook.buck.testutil.MoreAsserts;
 import com.facebook.buck.util.ProjectFilesystem;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSortedMap;
 import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.hash.HashCode;
 
 import org.easymock.EasyMockSupport;
 import org.junit.Test;
@@ -85,6 +90,9 @@
     List<Step> steps = accumulateClassNames.getBuildSteps(buildContext, buildableContext);
     verifyAll();
 
+    assertNotNull("The Supplier should be set as a side-effect of creating the steps.",
+        accumulateClassNames.classNames);
+
     // Verify the build steps.
     ProjectFilesystem projectFilesystem = new ProjectFilesystem(new File("."));
     ExecutionContext context = TestExecutionContext
@@ -100,4 +108,36 @@
         steps,
         context);
   }
+
+  @Test
+  public void testInitializeFromDisk() throws IOException {
+    BuildTarget buildTarget = new BuildTarget("//foo", "bar");
+    JavaLibraryRule javaRule = createMock(JavaLibraryRule.class);
+
+    replayAll();
+    AccumulateClassNames accumulateClassNames = new AccumulateClassNames(buildTarget, javaRule);
+    verifyAll();
+    resetAll();
+
+    OnDiskBuildInfo onDiskBuildInfo = createMock(OnDiskBuildInfo.class);
+    List<String> lines = ImmutableList.of(
+        "com/example/Bar 087b7707a5f8e0a2adf5652e3cd2072d89a197dc",
+        "com/example/Baz 62b1c2510840c0de55c13f66065a98a719be0f19",
+        "com/example/Foo e4fccb7520b7795e632651323c63217c9f59f72a");
+    expect(onDiskBuildInfo.getOutputFileContentsByLine(accumulateClassNames)).andReturn(lines);
+
+    replayAll();
+    accumulateClassNames.initializeFromDisk(onDiskBuildInfo);
+    verifyAll();
+
+    ImmutableSortedMap<String, HashCode> observedClasses = accumulateClassNames.getClassNames();
+    assertEquals(
+        "initializeFromDisk() should read the lines and use them to create an ImmutableSortedMap.",
+        ImmutableSortedMap.of(
+          "com/example/Bar", HashCode.fromString("087b7707a5f8e0a2adf5652e3cd2072d89a197dc"),
+          "com/example/Baz", HashCode.fromString("62b1c2510840c0de55c13f66065a98a719be0f19"),
+          "com/example/Foo", HashCode.fromString("e4fccb7520b7795e632651323c63217c9f59f72a")
+        ),
+        observedClasses);
+  }
 }
diff --git a/test/com/facebook/buck/rules/OnDiskBuildInfoTest.java b/test/com/facebook/buck/rules/OnDiskBuildInfoTest.java
new file mode 100644
index 0000000..6c9d0ee
--- /dev/null
+++ b/test/com/facebook/buck/rules/OnDiskBuildInfoTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2013-present Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License. You may obtain
+ * a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package com.facebook.buck.rules;
+
+import static org.easymock.EasyMock.expect;
+import static org.junit.Assert.assertEquals;
+
+import com.facebook.buck.model.BuildTarget;
+import com.facebook.buck.util.ProjectFilesystem;
+import com.google.common.collect.ImmutableList;
+
+import org.easymock.EasyMockSupport;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.List;
+
+public class OnDiskBuildInfoTest extends EasyMockSupport {
+
+  @Test
+  public void testGetOutputFileContentsByLine() throws IOException {
+    String pathToOutputFile = "buck-out/gen/java/com/example/classes.txt";
+
+    ProjectFilesystem projectFilesystem = createMock(ProjectFilesystem.class);
+    List<String> lines = ImmutableList.of(
+        "com/example/Bar.class 087b7707a5f8e0a2adf5652e3cd2072d89a197dc",
+        "com/example/Foo.class e4fccb7520b7795e632651323c63217c9f59f72a");
+    expect(projectFilesystem.readLines(Paths.get(pathToOutputFile))).andReturn(lines);
+
+    Buildable buildable = createMock(Buildable.class);
+    expect(buildable.getPathToOutputFile()).andReturn(pathToOutputFile);
+
+    replayAll();
+
+    OnDiskBuildInfo onDiskBuildInfo = new OnDiskBuildInfo(
+        new BuildTarget("//java/com/example", "ex"),
+        projectFilesystem);
+    List<String> observedLines = onDiskBuildInfo.getOutputFileContentsByLine(buildable);
+    assertEquals(lines, observedLines);
+
+    verifyAll();
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void testGetOutputFileContentsByLineRejectsNullBuildable() throws IOException {
+    ProjectFilesystem projectFilesystem = createMock(ProjectFilesystem.class);
+    OnDiskBuildInfo onDiskBuildInfo = new OnDiskBuildInfo(
+        new BuildTarget("//java/com/example", "ex"),
+        projectFilesystem);
+
+    replayAll();
+
+    onDiskBuildInfo.getOutputFileContentsByLine(null);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void testGetOutputFileContentsByLineRejectsNullOutputPath() throws IOException {
+    ProjectFilesystem projectFilesystem = createMock(ProjectFilesystem.class);
+    OnDiskBuildInfo onDiskBuildInfo = new OnDiskBuildInfo(
+        new BuildTarget("//java/com/example", "ex"),
+        projectFilesystem);
+
+    Buildable buildable = createMock(Buildable.class);
+    expect(buildable.getPathToOutputFile()).andReturn(null);
+
+    replayAll();
+
+    onDiskBuildInfo.getOutputFileContentsByLine(buildable);
+  }
+
+}