Java读取Evernote笔记 – 使用DeveloperToken

    在学习的时候，经常使用Evernote记录一下笔记或收藏一些有用的文章。如果通过Java读取Evernote文章哪？官方给处理授权接口。

1. 首先我们需要在Evernote的sandbox环境注册一个账户，https://sandbox.evernote.com/Registration.action
2. 有账户，如果希望使用java读取账户的信息，我们还需要申请一个Token，也就是一个授权码，有了授权，我们才能从账户里那东西。https://sandbox.evernote.com/api/DeveloperToken.action
3. 开发准备就绪，下面创建一个Maven项目，引入Evernote API

• 创建Maven项目：

  mvn archetype:generate -DgroupId=com.yotoo.app -DartifactId=simple -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

• 添加evernote  jdk依赖：

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.yotoo.app</groupId>
      <artifactId>simple</artifactId>
      <packaging>jar</packaging>
      <version>1.0-SNAPSHOT</version>
      <name>simple</name>
      <url>http://maven.apache.org</url>
      <dependencies>
          <dependency>
              <groupId>com.evernote</groupId>
              <artifactId>evernote-api</artifactId>
              <version>1.25.1</version>
          </dependency>
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>3.8.1</version>
              <scope>test</scope>
          </dependency>
      </dependencies>
  </project>

          4. 把项目导入Intellij IDEA或Eclipse随你喜欢，创建一个HelloEvernote类

        HelloEvernote类

• package com.yotoo.app;
  
  import com.evernote.auth.EvernoteAuth;
  import com.evernote.auth.EvernoteService;
  import com.evernote.clients.ClientFactory;
  import com.evernote.clients.NoteStoreClient;
  import com.evernote.clients.UserStoreClient;
  import com.evernote.edam.error.EDAMErrorCode;
  import com.evernote.edam.error.EDAMSystemException;
  import com.evernote.edam.error.EDAMUserException;
  import com.evernote.edam.notestore.NoteFilter;
  import com.evernote.edam.notestore.NoteList;
  import com.evernote.edam.type.*;
  import com.evernote.thrift.transport.TTransportException;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.security.MessageDigest;
  import java.util.Iterator;
  import java.util.List;
  
  public class HelloEvernote {
  
    // 去这里申请一个 Token https://sandbox.evernote.com/api/DeveloperToken.action
    private static final String AUTH_TOKEN = "填写授权Token";
  
    private UserStoreClient userStore;
    private NoteStoreClient noteStore;
    private String newNoteGuid;
  
    public static void main(String args[]) throws Exception {
      String token = System.getenv("AUTH_TOKEN");
      if (token == null) {
        token = AUTH_TOKEN;
      }
      if ("".equals(token)) {
        System.err.println("去这里申请一个Token https://sandbox.evernote.com/api/DeveloperToken.action");
        return;
      }
  
      HelloEvernote demo = new HelloEvernote(token);
      try {
        demo.listNotes();
        demo.createNote();
        demo.searchNotes();
        demo.updateNoteTag();
      } catch (EDAMUserException e) {
        // 需要处理的异常
        if (e.getErrorCode() == EDAMErrorCode.AUTH_EXPIRED) {
          System.err.println("授权的Token已经过期！");
        } else if (e.getErrorCode() == EDAMErrorCode.INVALID_AUTH) {
          System.err.println("无效的授权Token！");
        } else if (e.getErrorCode() == EDAMErrorCode.QUOTA_REACHED) {
          System.err.println("无效的授权Token！");
        } else {
          System.err.println("错误： " + e.getErrorCode().toString()
              + " 参数： " + e.getParameter());
        }
      } catch (EDAMSystemException e) {
        System.err.println("系统错误： " + e.getErrorCode().toString());
      } catch (TTransportException t) {
        System.err.println("网络错误：" + t.getMessage());
      }
    }
  
    /**
     * 初始化 UserStore and NoteStore 客户端
     */
    public HelloEvernote(String token) throws Exception {
      // 设置 UserStore 的客户端并且检查和服务器的连接
      EvernoteAuth evernoteAuth = new EvernoteAuth(EvernoteService.SANDBOX, token);
      ClientFactory factory = new ClientFactory(evernoteAuth);
      userStore = factory.createUserStoreClient();
  
      boolean versionOk = userStore.checkVersion("Evernote EDAMDemo (Java)",
          com.evernote.edam.userstore.Constants.EDAM_VERSION_MAJOR,
          com.evernote.edam.userstore.Constants.EDAM_VERSION_MINOR);
      if (!versionOk) {
        System.err.println("不兼容的Evernote客户端协议");
        System.exit(1);
      }
  
      // 设置 NoteStore 客户端
      noteStore = factory.createNoteStoreClient();
    }
  
    /**
     * 获取并显示用户的笔记列表
     */
    private void listNotes() throws Exception {
      // 列出用户的Notes
      System.out.println("Listing notes:");
  
      // 首先，获取一个笔记本的列表
      List<Notebook> notebooks = noteStore.listNotebooks();
  
      for (Notebook notebook : notebooks) {
        System.out.println("Notebook: " + notebook.getName());
  
        // 然后，搜索笔记本中前100个笔记并按创建日期排序
        NoteFilter filter = new NoteFilter();
        filter.setNotebookGuid(notebook.getGuid());
        filter.setOrder(NoteSortOrder.CREATED.getValue());
        filter.setAscending(true);
  
        NoteList noteList = noteStore.findNotes(filter, 0, 100);
        List<Note> notes = noteList.getNotes();
        for (Note note : notes) {
          System.out.println(" * " + note.getTitle());
        }
      }
      System.out.println();
    }
  
    /**
     * 创建一个新的笔记
     */
    private void createNote() throws Exception {
      // 创建一个新的笔记对象，并填写相关内容，比如标题等
      Note note = new Note();
      note.setTitle("Yotoo的Demo演示：通过Java创建一个新的笔记");
  
      String fileName = "enlogo.png";
      String mimeType = "image/png";
  
      // 给笔记添加一个附件，比如图片；首先创建一个资源对象，然后设置相关属性，比如文件名
      Resource resource = new Resource();
      resource.setData(readFileAsData(fileName));
      resource.setMime(mimeType);
      ResourceAttributes attributes = new ResourceAttributes();
      attributes.setFileName(fileName);
      resource.setAttributes(attributes);
  
      //现在，给新的笔记增加一个新的资源对象
      note.addToResources(resource);
  
      // 这个资源对象作为笔记的一部分显示
      String hashHex = bytesToHex(resource.getData().getBodyHash());
  
      // Evernote笔记的内容是通过ENML（Evernote Markup Language）语言生成的。
      // 在这里可以了解具体的说明 http://dev.evernote.com/documentation/cloud/chapters/ENML.php
      String content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
          + "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">"
          + "<en-note>"
          + "<span style=\"color:green;\">Evernote的图标在这里，很绿奥！</span><br/>"
          + "<en-media type=\"image/png\" hash=\"" + hashHex + "\"/>"
          + "</en-note>";
      note.setContent(content);
  
      // 最后，使用createNote方法，发送一个新的笔记给Evernote。
      // 返回的新笔记对象将包含服务器生成的属性,如新笔记的的GUID
      Note createdNote = noteStore.createNote(note);
      newNoteGuid = createdNote.getGuid();
  
      System.out.println("成功创建一个新的笔记，GUID为：" + newNoteGuid);
      System.out.println();
    }
  
    /**
     * 查询用户的笔记并显示结果
     */
    private void searchNotes() throws Exception {
      // 搜索的格式需要根据Evernote搜索语法，
      // 参考这里http://dev.evernote.com/documentation/cloud/chapters/Searching_notes.php
  
      // 在这个例子中，我们搜索的标题中包含Yotoo
      String query = "intitle:Yotoo";
  
      // 搜索的笔记中包含具体标签，我可以使用这个：
      // String query = "tag:tagname";
      // 搜索任何位置包含"Yotoo"的笔记，可以使用：
      // String query = "Yotoo";
  
      NoteFilter filter = new NoteFilter();
      filter.setWords(query);
      filter.setOrder(NoteSortOrder.UPDATED.getValue());
      filter.setAscending(false);
  
      // 查询前50个满足条件的笔记
      System.out.println("满足查询条件的笔记： " + query);
      NoteList notes = noteStore.findNotes(filter, 0, 50);
      System.out.println("找到 " + notes.getTotalNotes() + " 个笔记");
  
      Iterator<Note> iter = notes.getNotesIterator();
      while (iter.hasNext()) {
        Note note = iter.next();
        System.out.println("笔记： " + note.getTitle());
  
        // 通过findNotes()返回的Note对象，仅包含笔记的属性，标题，GUID，创建时间等，但笔记的内容和二进制数据都省略了；
        // 获取笔记的内容和二进制资源,可以调用getNote()方法获取
        Note fullNote = noteStore.getNote(note.getGuid(), true, true, false,
            false);
        System.out.println("笔记包含 " + fullNote.getResourcesSize()
            + " 个资源对象");
        System.out.println();
      }
    }
  
    /**
     * 更新标签分配给一个笔记。这个方法演示了如何调用updateNote方法发送被修改字段
     */
    private void updateNoteTag() throws Exception {
      // 当更新一个笔记时，只需要发送已经修改的字段。
      // 例如，通过updateNote发送的Note对象中没有包含资源字段，那么Evernote服务器不会修改已经存在的资源属性
      // 在示例代码中,我们获取我们先前创建的笔记,包括 笔记的内容和所有资源。
      Note note = noteStore.getNote(newNoteGuid, true, true, false, false);
  
      //现在,更新笔记。复原内容和资源，因为没有修改他们。我们要修改的是标签。
      note.unsetContent();
      note.unsetResources();
  
      // 设置一个标签
      note.addToTagNames("TestTag");
  
      // 现在更新笔记，我们没有设置内容和资源，所以他们不会改变
      noteStore.updateNote(note);
      System.out.println("成功增加标签");
  
      // 证明一下我们没有修改笔记的内容和资源；重新取出笔记，它仍然只有一个资源（图片）
      note = noteStore.getNote(newNoteGuid, false, false, false, false);
      System.out.println("更新以后, 笔记有 " + note.getResourcesSize()
          + " 个资源");
      System.out.println("更新以后，笔记的标签是： ");
      for (String tagGuid : note.getTagGuids()) {
        Tag tag = noteStore.getTag(tagGuid);
        System.out.println("* " + tag.getName());
      }
  
      System.out.println();
    }
      /**
       * 从磁盘读取文件的内容并创建数据对象
       */
      private static Data readFileAsData(String fileName) throws Exception {
          String filePath = new File(HelloEvernote.class.getResource(
                  "com.yotoo.app.HelloEvernote.class").getPath()).getParent()
                  + File.separator + fileName;
          // 读取文件的二进制内容
          FileInputStream in = new FileInputStream(filePath);
          ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
          byte[] block = new byte[10240];
          int len;
          while ((len = in.read(block)) >= 0) {
              byteOut.write(block, 0, len);
          }
          in.close();
          byte[] body = byteOut.toByteArray();
  
          // 创建一个新的包含文件内容的二进制对象
          Data data = new Data();
          data.setSize(body.length);
          data.setBodyHash(MessageDigest.getInstance("MD5").digest(body));
          data.setBody(body);
  
          return data;
      }
  
    /**
     * 把byte数组转换成hexadecimal字符串
     */
    public static String bytesToHex(byte[] bytes) {
      StringBuilder sb = new StringBuilder();
      for (byte hashByte : bytes) {
        int intVal = 0xff & hashByte;
        if (intVal < 0x10) {
          sb.append('0');
        }
        sb.append(Integer.toHexString(intVal));
      }
      return sb.toString();
    }
  }

    5. 把Evernote的图标放在HelloEvernote 类的同级目录。 

    6. 执行一下看看，如果在Evernote账户下创建了一个新的笔记，说明已经学会啦。