本来嘛，点进这个页面，会看到正常的counter数据，但是，出问题的情况下，点进去看到的是这种情况：

同时，在shell命令行你也会发现，该job没有任何counter信息输出。
从错误信息页上，你得不到关于错误的任何有效信息，那个"Error Details"里也没有。
虽然counter无法显示，但M-R job是可以正常跑完、正常输出数据的。
文章来源：https://www.codelast.com/
经过测试，我这个case的的问题是：在程序中添加了数量比较多的Hadoop counter造成的。
什么算多？我不知道。我的程序里有240多个counter就出问题了，当我把counter缩减了一半，最终只有120多个counter的时候，counter信息统计就正常了。
如果你遇到了类似问题，可以首先检查一下job中的counter数量是否太多。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

static class QuerySegmentResultFromKVReducer extends Reducer<Text, NullWritable, NullWritable, NullWritable> {

  @Override
  protected void setup(Reducer.Context context) throws IOException, InterruptedException {
  }

  @Override
  protected void cleanup(Reducer.Context context) throws IOException, InterruptedException {
  }

  @Override
  protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
    //TODO:
  }
}

在这里，reducer输出的key、value类型都是NullWritable，我们不用关心，这不是本文的关注点。

如果reduce()方法漏掉了 @Override 注解，并且把  Reducer<Text, NullWritable, NullWritable, NullWritable> 错误地写成了 Reducer<Text, Text, NullWritable, NullWritable>，会发现编译并不报错。
但是，当你跑这个job的时候，诡异的事情就来了。你会发现，你在“TODO:”那里写的reduce逻辑并没有执行，即使没有用 context.write() 方法把任何数据输出到HDFS上，Hadoop counter仍然显示该job输出了和reducer输入一样多的数据。
从现象上看，就像是执行了一个默认的Reducer，把reducer的输入数据原样输出。
文章来源：https://www.codelast.com/
所以这里不得不强调，一定不要漏写 @Override 注解！有这个注解的时候，IDE就会提示错误，编译就会失败！

在本文的例子中，如果reduce()方法没有写 @Override 注解，那么当reducer类错误地定义成了extends Reducer<Text, Text, NullWritable, NullWritable>的时候，IDE并不会发现reduce()方法有错，从而让你误以为一切正常。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

在大数据处理流程中，TFRecord文件通常是由map-reduce job生成的，数据量通常很大。有时为了验证文件内容正确，我们需要取少量数据来检查，例如，我们可以拿map-reduce job生成的N个TFRecord文件中的一个，在本地解析出来，打印出其中的内容看是否正确。
下面就是一个用JAVA程序读取TFRecord文件并打印出其中一个Example的例子：

    String localTfRecordFile = "/path/to/your/tfrecord/file";
    InputStream inputStream = Files.newInputStream(Paths.get(localTfRecordFile));
    DataInput dataInput = new DataInputStream(inputStream);
    TFRecordReader reader = new TFRecordReader(dataInput, true);

    byte[] recordBytes = reader.read();
    while (recordBytes != null) {
      Example example = Example.parseFrom(recordBytes);
      System.out.println(example.toString());
      break;  // 只打印一个Example
    }
    inputStream.close();

唯一需要注意的就是一个引入：import java.nio.file.Paths;
文章来源：https://www.codelast.com/
再详细说明一下：

话不多说，直接上代码：

    Configuration conf = new Configuration();
    FileSystem fs = FileSystem.getLocal(conf);
    Path seqFilePath = new Path("/path/to/your/sequence-file");

    {
      // 打印出sequence file的key和value的类型
      SequenceFile.Reader reader = new SequenceFile.Reader(fs, seqFilePath, conf);
      Writable key = (Writable) reader.getKeyClass().newInstance();
      Writable value = (Writable) reader.getValueClass().newInstance();
      while (reader.next(key, value)) {
        System.out.println("Key type: " + key.getClass());
        System.out.println("Value type: " + value.getClass());
        break;
      }
      reader.close();
    }

    {
      // 打印出sequence file的内容
      SequenceFile.Reader reader = new SequenceFile.Reader(fs, seqFilePath), conf);
      BooleanWritable keyObj = new BooleanWritable();
      Text valueObj = new Text();
      while (reader.next(keyObj, valueObj)) {
        System.out.println(keyObj.get() + ": " + valueObj);
      }
      reader.close();
    }

输出类似于：

Key type: class org.apache.hadoop.io.BooleanWritable

Value type: class org.apache.hadoop.io.Text
（文件内容此处省略）

Maven依赖取决于你使用的Hadoop版本，下面是一个例子：

<dependencies>
  <dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-common</artifactId>
    <version>3.2.1</version>
  </dependency>
  <dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-client</artifactId>
    <version>3.2.1</version>
  </dependency>
  <dependency>
    <groupId>org.apache.hadoop</groupId>  
    <artifactId>hadoop-hdfs</artifactId>
    <version>3.2.1</version>
  </dependency>
</dependencies>

文章来源：https://www.codelast.com/
➤➤ 关注不迷路 ➤➤ 

感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

{
  "id": "...",
  "secret": "...",
  "endPoint": "http://...",
  "region": "..."
}

文章来源：https://www.codelast.com/
这些信息你可以在你使用的S3平台上找到。
假设我们要读写的bucket名为 my-bucket，那么下面的命令会告诉你怎么使用 s3-command-line：

列出指定 bucket 里的文件：
./s3-command-line ls -c config.json my-bucket /

从指定的 bucket 删除文件 1.txt：
./s3-command-line rm -c config.json my-bucket 1.txt

上传本地文件 1.txt 到指定的 bucket：
./s3-command-line put -c config.json my-bucket 1.txt

从指定的 bucket 下载文件 1.txt 到本地：
./s3-command-line get -c config.json my-bucket 1.txt

文章来源：https://www.codelast.com/
总结：简单好用，编译成可执行程序后没有对其他library的依赖，令人舒适。

➤ 自己写JAVA程序
JDK版本：1.8.0_221，Maven：3.6.3
首先你需要在 pom.xml 中添加相关依赖（参考这里）：

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>aws-sdk-java</artifactId>
  <version>2.18.16</version>
</dependency>

文章来源：https://www.codelast.com/
然后就可以开始写代码了（测试可用）：

package com.codelast;


import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.kohsuke.args4j.Option;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;
import software.amazon.awssdk.services.s3.model.S3Exception;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URI;

/**
 * S3存储操作类。
 * 参考：https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/PutObject.java
 *
 * @author DarranZhang@codelast.com
 * @version 2022-11-14
 */

@Slf4j
public class S3Operator {
  public static final String ACCESS_KEY = "your_key";
  public static final String SECRET_KEY = "your_secret";
  public static final String END_POINT = "http://your_end_point_url";
  public static final String REGION = "your_region";
  public static final String BUCKET_NAME = "your_bucket_name";

  private static class Options {
    @Option(name = "--localFile", usage = "the path of the local file to upload to S3", required = true)
    String localFile;
  }

  public static void main(String[] args) throws Exception {
    Options opts = new Options();
    CmdLineParser parser = new CmdLineParser(opts);
    try {
      parser.parseArgument(args);
    } catch (CmdLineException e) {
      log.error("command parse fail", e);
      System.exit(1);
    }

    S3Operator operator = new S3Operator();
    operator.upload(opts.localFile);
  }

  private void upload(String localFile) throws Exception {
    AwsBasicCredentials credentials = AwsBasicCredentials.create(ACCESS_KEY, SECRET_KEY);
    Region region = Region.of(REGION);
    S3Client s3Client = S3Client.builder()
      .endpointOverride(new URI(END_POINT))
      .region(region)
      .credentialsProvider(StaticCredentialsProvider.create(credentials))
      .build();

    String s3FileName = StringUtils.substringAfterLast(localFile, "/");  // 上传到S3之后的文件名，不一定要和本地文件名一致，但为了直观，这里保持一致
    if (StringUtils.isEmpty(s3FileName)) {
      String msg = "local file name is empty";
      log.error(msg);
      throw new RuntimeException(msg);
    }

    // 每次上传前，不用先删除再上传，因为最新上传的同名文件会覆盖之前的文件
    putObject(s3Client, BUCKET_NAME, s3FileName, localFile);
    s3Client.close();
  }

  public static void putObject(S3Client s3Client, String bucketName, String objectKey, String objectPath) {
    try {
      PutObjectRequest request = PutObjectRequest.builder().bucket(bucketName).key(objectKey).build();
      PutObjectResponse response = s3Client.putObject(request, RequestBody.fromBytes(getObjectFile(objectPath)));
      log.info("successfully upload file [{}] to S3, entity tag: [{}]", objectPath, response.eTag());
    } catch (S3Exception e) {
      log.error(String.format("failed to upload file [%s] to S3", objectPath), e);
    }
  }

  private static byte[] getObjectFile(String filePath) {
    FileInputStream fileInputStream = null;
    byte[] bytesArray = null;

    try {
      File file = new File(filePath);
      bytesArray = new byte[(int) file.length()];
      fileInputStream = new FileInputStream(file);
      fileInputStream.read(bytesArray);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      if (fileInputStream != null) {
        try {
          fileInputStream.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
    return bytesArray;
  }

  private static void deleteObject(S3Client s3, String bucket, String s3FileName) {
    DeleteObjectRequest request = DeleteObjectRequest.builder().bucket(bucket).key(s3FileName).build();
    s3.deleteObject(request);
  }
}

这样我们就实现了用JAVA访问S3，不过，如果你仔细看会发现，当引入S3的依赖后，你的项目编译出的 fat jar 体积剧增了400MB左右！这也太恶心了...
当然，上面引入的 whole-SDK 依赖，是我为了省事引入了所有S3相关的模块，或许你有些用不到的模块，可以不用引入 whole-SDK，而是分别引入单独的模块，但我有空去想这些玩意的话，还不如使用 s3-command-line 简单呢，不是吗？毕竟时间就是生命，别在这些无聊的事上浪费生命。
文章来源：https://www.codelast.com/
➤ 总结
如果你操作S3时只使用上传、下载、删除、列表功能，那么建议不要自己写代码，使用 s3-command-line 更香。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

public String performHttpPost(String url, String payload, Map<String, String> headers) {
  HttpRequestFactory requestFactory = new NetHttpTransport().createRequestFactory();
  HttpRequest request;
  try {
    byte[] contentBytes = payload.getBytes(Charsets.UTF_8);
    HttpContent content = new ByteArrayContent("application/json", contentBytes);
    request = requestFactory.buildPostRequest(new GenericUrl(url), content);
    if (MapUtils.isNotEmpty(headers)) {
      for (Map.Entry<String, String> entry : headers.entrySet()) {
        request.getHeaders().set(entry.getKey(), entry.getValue());
      }
    }
    return request.execute().parseAsString();
  } catch (IOException e) {
    log.error("failed to send POST request", e);
  }
}

其中，payLoad是你要发送的JSON数据字符串，headers是要设置到请求头中的key-value对。
文章来源：https://www.codelast.com/
➤ OkHttpClient

public String performHttpPost(String url, String payload) {
  HttpUrl.Builder builder = null;
  try {
    HttpUrl httpUrl = HttpUrl.parse(url);
    if (httpUrl != null) {
      builder = httpUrl.newBuilder();
    }
  } catch (IllegalArgumentException e) {
    log.error("failed to create HttpUrl.Builder from url: {}", url, e);
  }
  if (builder == null) {
    return null;
  }
  OkHttpClient client = new OkHttpClient();
  RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), payload);
  Request request = new Request.Builder()
    .url(builder.build())
    .post(requestBody)
    .build();
  try {
    Response response = client.newCall(request).execute();
    ResponseBody body = response.body();
    if (body == null) {
      log.error("null response body");
      return null;
    }
    return body.string();
  } catch (IOException e) {
    log.error("failed to send POST request", e);
  }
  return null;
}

其中，payLoad是你要发送的JSON数据字符串。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

[
    {
        "sku": "ABC",
        "num": 3
    },
    {
        "sku": "DEF",
        "num": 2
    }
]

由中括号可知，这个JSON字符串映射成JAVA对象是一个List，而它里面又包含了两个JAVA对象（每个大括号对应一个）。

假设JSON字符串 { "sku": "ABC", "num": 3 } 映射成的POJO为：

public class SkuInfo {
  private String sku;
  private int num;
}

那么，应该怎么用Jackson库来解析原JSON？
文章来源：https://www.codelast.com/
由于JSON字符串 { "sku": "ABC", "num": 3 } 是无名（匿名）的，所以要用这样的方法来解析它：

final ObjectMapper mapper = new ObjectMapper();
SkuInfo[] skuInfos = mapper.readValue(FileUtils.readFileToString(new File("1.json"), Charsets.UTF_8), SkuInfo[].class);

或者你不想把JSON解析成一个JAVA数组，而是一个List的话，可以这么做：

List<SkuInfo> skuInfos = MAPPER.readValue(FileUtils.readFileToString(new File("1.json"), Charsets.UTF_8),
      new TypeReference<List<SkuInfo>>() {});

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

wait.until(ExpectedConditions.alertIsPresent());
Alert alert = driver.switchTo().alert();
alert.accept();

在升级了pom.xml中的selenium-java版本到3.141.59后，代码编译出错了（挂在第一行），错误信息：

无法将类 org.openqa.selenium.support.ui.FluentWait<T>中的方法 until应用到给定类型;

[ERROR]   需要: java.util.function.Function<? super org.openqa.selenium.WebDriver,V>

[ERROR]   找到: org.openqa.selenium.support.ui.ExpectedCondition<org.openqa.selenium.Alert>

[ERROR]   原因: 无法推断类型变量 V

[ERROR]     (参数不匹配; org.openqa.selenium.support.ui.ExpectedCondition<org.openqa.selenium.Alert>无法转换为java.util.function.Function<? super org.openqa.selenium.WebDriver,V>)

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>19.0</version>
</dependency>

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>21.0</version>
</dependency>

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

✓ 适用的Hadoop版本
CDH 5.8.0（Hadoop 2.6.0）
别的版本没有测试过，但后面相近的版本应该也能用。

✓ 准备工作：上传本地文件到HDFS
为了在Java代码中把一个文件加入 distributed cache，需要先把它上传到HDFS，之后应使用 HDFS 路径来加入 distributed cache。
假设要加入 distributed cache 的文件为 file.txt：

hadoop fs -put file.txt /your/hdfs/dir/

✓ job 配置

    String fileName = "file.txt";
    String filePathHdfs = "/your/hdfs/dir/file.txt";

    Job job = Job.getInstance(getConf());
    Configuration conf = job.getConfiguration();
    conf.set("fileName", fileName);
    conf.set("filePathHdfs", filePathHdfs);

    job.addCacheFile(new URI(String.format("%s#%s", filePathHdfs, fileName)));

文章来源：https://www.codelast.com/
这里往 conf 里塞了两个变量，一个是文件名 fileName，另一个是文件的HDFS路径 filePathHdfs，并且在 addCacheFile() 的时候，拼成了 /your/hdfs/dir/file.txt#file.txt 这样奇怪的形式，这种形式使得在 mapper 或 reducer 中读取 distributed cache 文件的时候，直接用文件名就能读出文件，特别方便！

✓ 在 mapper 或 reducer 的 setup() 方法中读取 distributed cache 文件

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
      Configuration conf = context.getConfiguration();

      File myFile = new File(conf.get("file.txt"));
      FileInputStream fis = new FileInputStream(myFile);
      BufferedReader reader = new BufferedReader(new InputStreamReader(fis));

      String line;
      while ((line = reader.readLine()) != null) {
        //TODO: deal with each line
      }
    }

看到没？上面的 conf.get("file.txt") 就只使用了文件名就能找到 distributed cache 里的文件，可以做这样“神奇”的操作是因为背后有一种叫symbolic link的技术。
下面留空的 TODO 那里，需要你自己填写处理每一行数据的逻辑。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

{"aaa":"{\"ccc\":\"ccc\",\"ddd\":\"ddd\"}","bbb":{"ccc":"ccc","ddd":"ddd"}}

现在要用Jackson解析它为一个Java对象，怎么做？

我们先把这个JSON格式化，便于观察它的结构：

{
    "aaa": "{\"ccc\":\"ccc\",\"ddd\":\"ddd\"}", 
    "bbb": {
        "ccc": "ccc", 
        "ddd": "ddd"
    }
}

所以按照Jackson的套路，我们似乎很容易就可以写出对应的JSON解析代码，先定义几个POJO：
A.java 的主要代码：

public class A {
  private AAA aaa;
  private BBB bbb;

  public AAA getAaa() {
    return aaa;
  }

  public void setAaa(AAA aaa) {
    this.aaa = aaa;
  }

  public BBB getBbb() {
    return bbb;
  }

  public void setBbb(BBB bbb) {
    this.bbb = bbb;
  }
}

文章来源：https://www.codelast.com/
AAA.java 的主要代码：

public class AAA {
  private String ccc;
  private String ddd;

  public String getCcc() {
    return ccc;
  }

  public void setCcc(String ccc) {
    this.ccc = ccc;
  }

  public String getDdd() {
    return ddd;
  }

  public void setDdd(String ddd) {
    this.ddd = ddd;
  }
}

文章来源：https://www.codelast.com/
BBB.java 的主要代码：

public class BBB {
  private String ccc;
  private String ddd;

  public String getCcc() {
    return ccc;
  }

  public void setCcc(String ccc) {
    this.ccc = ccc;
  }

  public String getDdd() {
    return ddd;
  }

  public void setDdd(String ddd) {
    this.ddd = ddd;
  }
}

文章来源：https://www.codelast.com/
然后就是解析的逻辑：

String json = FileUtils.readFileToString(new File("/home/codelast/codelast.json"));
ObjectMapper mapper = new ObjectMapper();
A data = mapper.readValue(json, A.class);

我们的目的是把codelast.json这个文件里保存的JSON字符串解析成类A的一个对象data。

这不是很简单嘛？要不运行一下试试看？
马上报错：

com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot construct instance of `com.codelast.AAA` (although at least one Creator exists): no String-argument constructor/factory method to deserialize from String value ('{"ccc":"ccc","ddd":"ddd"}')
 at [Source: (String)"{"aaa":"{\"ccc\":\"ccc\",\"ddd\":\"ddd\"}","bbb":{"ccc":"ccc","ddd":"ddd"}}
"; line: 1, column: 8] (through reference chain: com.codelast.A["aaa"])

at com.fasterxml.jackson.databind.exc.MismatchedInputException.from(MismatchedInputException.java:63)
at com.fasterxml.jackson.databind.DeserializationContext.reportInputMismatch(DeserializationContext.java:1342)
at com.fasterxml.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1031)
at com.fasterxml.jackson.databind.deser.ValueInstantiator._createFromStringFallbacks(ValueInstantiator.java:371)
at com.fasterxml.jackson.databind.deser.std.StdValueInstantiator.createFromString(StdValueInstantiator.java:323)
at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromString(BeanDeserializerBase.java:1366)
at com.fasterxml.jackson.databind.deser.BeanDeserializer._deserializeOther(BeanDeserializer.java:171)
at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:161)
at com.fasterxml.jackson.databind.deser.impl.MethodProperty.deserializeAndSet(MethodProperty.java:127)
at com.fasterxml.jackson.databind.deser.BeanDeserializer.vanillaDeserialize(BeanDeserializer.java:288)
at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:151)
at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:4001)
at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:2992)

这是什么情况？事实上，这就是由于JSON的“aaa”这个字段里面包含转义字符造成的，如果你Google一下，可能会找到这个知乎帖子，它告诉我们，要为Jackson的 ObjectMapper 设置一个属性为true：Feature.ALLOW_UNQUOTED_CONTROL_CHARS
所以我们可以试试：

String json = FileUtils.readFileToString(new File("/home/codelast/codelast.json"));
ObjectMapper mapper = new ObjectMapper();
mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
A data = mapper.readValue(json, A.class);

再执行代码，会发现报一样的错。
所以上面的解决方案是无效的。
文章来源：https://www.codelast.com/
正确解决这个问题的办法，是参考 Stack Overflow的这个帖子。里面说到，应该创建一个 JsonDeserializer 来搞定这个问题。下面，我就把正确的代码依次贴上来：
A.java 的主要代码（和之前不一样，这里使用了一个自定义的 AAADeserializer）：

public class A {
  @JsonDeserialize(using = AAADeserializer.class)
  private AAA aaa;

  private BBB bbb;

  public AAA getAaa() {
    return aaa;
  }

  public void setAaa(AAA aaa) {
    this.aaa = aaa;
  }

  public BBB getBbb() {
    return bbb;
  }

  public void setBbb(BBB bbb) {
    this.bbb = bbb;
  }
}

文章来源：https://www.codelast.com/
AAA.java、BBB.java 和之前完全一样，不重复贴代码上来。
下面就是关键的 AAADeserializer.java 的主要代码：

public class AAADeserializer extends JsonDeserializer<AAA> {
  private static final ObjectMapper mapper = new ObjectMapper();

  @Override
  public AAA deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
    return mapper.readValue(jsonParser.getText(), AAA.class);
  }
}

文章来源：https://www.codelast.com/
然后就可以解析JSON了：

String json = FileUtils.readFileToString(new File("/home/codelast/codelast.json"));
ObjectMapper mapper = new ObjectMapper();
A data = mapper.readValue(json, A.class);

你这时候再运行一下这段代码，就会发现不再报错，JSON已经成功解析到对象 data 中，问题解决！

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

• 使用简单的线程
• 使用TimerTask
• 使用ScheduledExecutorService

• 使用简单的线程

public class Task1 {
public static void main(String[] args) {
  // run in a second
  final long timeInterval = 1000;
  Runnable runnable = new Runnable() {
  public void run() {
    while (true) {
      // ------- code for task to run
      System.out.println("Hello !!");
      // ------- ends here
      try {
       Thread.sleep(timeInterval);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      }
    }
  };
  Thread thread = new Thread(runnable);
  thread.start();
  }
}

文章来源：http://www.codelast.com/

• 使用Timer和TimerTask

之前我们看到的方法极其简单快速，但是它缺少一些功能。

import java.util.Timer;
import java.util.TimerTask;

public class Task2 {
  public static void main(String[] args) {
    TimerTask task = new TimerTask() {
      @Override
      public void run() {
        // task to run goes here
        System.out.println("Hello !!!");
      }
    };
    Timer timer = new Timer();
    long delay = 0;
    long intevalPeriod = 1 * 1000; 
    // schedules the task to be run in an interval 
    timer.scheduleAtFixedRate(task, delay,
                                intevalPeriod);
  } // end of main
}

从JDK 1.3开始这些类就已经有了。
文章来源：http://www.codelast.com/

• 使用ScheduledExecutorService

这个类是从Java SE 5开始作为并发工具引入的，位于包java.util.concurrent中。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Task3 {
  public static void main(String[] args) {
    Runnable runnable = new Runnable() {
      public void run() {
        // task to run goes here
        System.out.println("Hello !!");
      }
    };
    ScheduledExecutorService service = Executors
                    .newSingleThreadScheduledExecutor();
    service.scheduleAtFixedRate(runnable, 0, 1, TimeUnit.SECONDS);
  }
}

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

『2』修改IDE的项目设置
如上所述，修改IDE的项目设置可以使得在IDE中run test的时候通过，但是对诸如Jenkins之类的工具执行的nightly build（最终是通过build.xml实现的），仅仅修改IDE设置是没用的，nightly build依然会挂掉。所以这种方法只能保证“临时用用”。
文章来源：http://www.codelast.com/
『3』动态添加目录到classpath中
本文的主角登场了。
如果我们能在单元测试中，添加一些代码，动态地将需要的目录添加到classpath中，那么问题不就从最根本上解决了吗？不仅不用修改IDE里的项目设置，也不用修改build.xml，好多啊。是的，你只需要在单元测试中的setUp()里添加下面的代码：

@Before

public void setUp() throws Exception {
    File programRootDir = new File("./");
    URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
    Method add = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
    add.setAccessible(true);
    add.invoke(classLoader, programRootDir.toURI().toURL());
}

就可以把目录动态添加到classpath中了。在这里，代码中的“./”表示我把项目的根目录添加到了classpath中。
修改之后，无论是在IDE中run unit test，还是在命令行ant test，都完全没问题了。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

What follows is a practical introduction to a specific type of memory problems in Java applications. Namely – we will analyze the errors that cause the java.lang.OutOfMemoryError: PermGen spacesymptom in the stack trace.
本文实用性地介绍了Java程序的一个特殊的内存问题，即——我们将分析stack trace中产生java.lang.OutOfMemoryError: PermGen space错误的原因。

First of all we will go through the core concepts required to understand the subject – and explain what objects, classes, classloaders and the JVM memory model are. If you are familiar with the basic concepts, you can jump directly to the next section where I will describe two typical cases for the error in question alongside with hints and suggestions for solving it.
首先，我们来看看理解该主题所需的核心概念，并且解释一下什么是对象（objects），类（classes），类加载器（classloaders）以及JVM内存模型（JVM memory model）。如果你已经熟知了这些基础概念，可以直接跳到下一节，我在它里面讨论了两种产生该错误的典型原因，以及解决此问题的提示和建议。
文章来源：http://www.codelast.com/

Objects, Classes and ClassLoaders

对象（Objects），类（Classes）以及类加载器（ClassLoaders）

Well, I will not start with the very basics. I guess if you have already found us, you should be familiar with the concept that everything in Java is an Object. And that all Objects are specified by their Class. So every object has a reference to an instance of java.lang.Class describing the structure of that object’s class.

But what actually happens under the hood, when you create a new object in your code? For example if you write something truly complicated like

Person boss = new Person();

The Java Virtual Machine (JVM) needs to understand the structure of the object to create. To achieve this, the JVM looks for the class called Person. And if the Person class is accessed for the first time during this particular execution of the program, it has to be loaded by the JVM, normally from the corresponding Person.class file. The process of seeking for the Person.class file on the drive, loading it into memory and parsing it’s structure is called class loading. Ensuring proper class loading process is the responsibility of a ClassLoader. ClassLoaders are instances of java.lang.ClassLoader class and each and every class in a Java program has to be loaded by some ClassLoader. As a result we now have the following relationships:
Java虚拟机（JVM）需要理解待创建对象的结构，为此，JVM会查找叫Person的类。并且，如果在程序的这一次运行中，Person类是第一次被访问的话，它必须要被JVM加载（loaded），通常这是从对应的Person.class文件加载的。从磁盘上查找Person.class文件、将其加载到内存中，并解析它的结构的过程，就叫作类的加载（class loading）。保证合适的类被加载是类加载器（ClassLoader）的职责。ClassLoader是java.lang.ClassLoader类的实例，并且Java程序中的每一个类都必须被一些ClassLoader加载。最后，我们可以得到下面的关系图：

文章来源：http://www.codelast.com/
As you can see from the next diagram every classloader holds references to all the classes it has loaded. For the purpose of our article these relationships are very interesting.
从下一幅图你可以看到，每一个classloader都持有它所加载的所有类的引用。由于本文的主旨的原因，这些关系非常有趣。

Remember this image, we will need it later.
记住这幅图，我们稍后会用到它。
文章来源：http://www.codelast.com/

Permanent Generation

永久代

Almost every JVM nowadays uses a separate region of memory, called the Permanent Generation (orPermGen for short), to hold internal representations of java classes. PermGen is also used to store more information – find out the details from this post if you are interested – but for our article it is safe to assume that only the class definitions are being stored in PermGen. The default size of this region on my two machines running java 1.6 is not a very impressive 82MB.
当今，几乎所有JVM都使用一个称为永久代（Permanent Generation，或者简写为PermGen）的独立内存区域来保存Java类的内在表征。PermGen也用来保存更多信息——如果感兴趣的话，你可以看看这篇文章——但是对本文来说，我们可以假定PermGen只保存类的定义。对我那运行Java 1.6的机器来说，此内存区域的默认大小是82MB，一个很普通的数值。

As I have explained in one of my earlier posts, a memory leak in Java is a situation where some objects are no longer used by an application, but the Garbage Collector fails to recognize them as unused. This leads to the OutOfMemoryError if those unused objects contribute to the heap usage significantly enough that the next memory allocation request by the application cannot be fulfilled.
就像我在以前一篇文章中解释的那样，Java的内存泄漏是指某些对象不再被应用程序使用，而垃圾收集器（Garbage Collector）却没能识别它们是“不再使用的”。如果那些不使用的对象占用堆（heap）空间足够大，使得应用程序无法满足下一次内存分配需求，就会导致OutOfMemoryError错误。

The root cause of java.lang.OutOfMemoryError: PermGen space is exactly the same: the JVM needs to load the definition of a new class but there is not enough space in PermGen to do it – there are already too many classes stored there. A possible reason for this could be your application or server using too many classes for the current size of PermGen not to be able to accommodate them. Another commone reason could be a memory leak.
java.lang.OutOfMemoryError: PermGen space错误的根本原因也是完全一样的：JVM需要加载一个新类的定义，而永久代（PermGen）的空间不足——已经有太多的类存储在那里了。一个可能的原因是：你的应用程序或服务器使用了太多的类，当前的永久代（PermGen）大小无法满足需求。另一个原因可能是内存泄漏。
文章来源：http://www.codelast.com/

Permanent Generation Leak

永久代（内存）泄漏

But still, how on earth it is possible to leak something in PermGen? It holds definitions of java classes and they cannot become unused, can they? Actually, they can. In case of a Java web application deployed into an application server all those classes in your EAR/WAR become worthless when the application is undeployed. The JVM continues to run as the application server is still alive, but a whole bunch of class definitions are not in use anymore. And they should be removed from PermGen. If not, we will have memory leak in the PermGen area.
但是，永久代（PermGen）到底有没有可能会内存泄漏？它保存了Java类定义，并且这些类定义是不会变成“无用”的，是吗？事实上，它们是可以变成“无用”的。以一个部署到应用程序服务器的Java web程序来说，当该应用程序被卸载的时候，你的EAR/WAR包中的所有类都将变得无用。只要应用程序服务器还活着，JVM将继续运行，但是一大堆的类定义将不再使用，理应将它们从永久代（PermGen）中移除。如果不移除的话，我们在永久代（PermGen）区域就会有内存泄漏。

As a nice sample on the reasons – the Tomcat developers have set up a Wiki page describing different leaks found and fixed in the Apache Tomcat versions 6.0.24 and above.
这里有一个说明内存泄漏的原因的好例子——Tomcat的开发者们写了一个Wiki页面来描述在Apache Tomcat 6.0.24及之后的版本中发现、修复的不同的内存泄漏原因。
文章来源：http://www.codelast.com/

Leaking Threads

线程内存泄漏

One possible scenario for a classloader leak is through long running threads. This happens when your application or – as often was the case in my experience – a 3rd party library used by your application, starts some long running thread. An example of this could be a timer thread whose job is to execute some code periodically.
类加载器（classloader）泄漏的一个可能的场景就是通过运行的线程（而内存泄漏）。当你的程序，或者你的程序使用的第三方库（我经常遇到这种情况）开启了一些长时间运行的线程。一个例子：一个用于周期性执行代码的计时器（timer）线程。

If the intended lifespan of this thread is not fixed, we are heading directly into a trouble. When any part of your application ever starts a thread, you must make sure that it is not going to outlive the application. In typical cases the developer either is not aware of this responsibility or simply forgets to write the clean-up code.
如果不解决该线程预期的生命周期问题，我们直接会遇到麻烦。当你程序的任何一部分启动一个线程的时候，你要确保它不会比程序活得还要久。在典型的情况下，开发者要么不知道自己有责任处理好这个问题，或者忘了写清理（clean-up）的代码。

Otherwise, if some thread continues to run after the application is undeployed, it will, usually, hold a reference to a classloader of the web application it was started by, called context classloader. Which in turn means that all classes of the undeployed application continue to be held in memory. Remedy? If it is your application that starts new threads, you should shut them down during undeployment using a servlet context listener. If it is a 3rd party library, you should search for its own specific shutdown hook. Or file a bug report if there is none.
否则，如果应用程序卸载后，线程还在继续运行，它通常将维持一个到web应用程序的classloader的引用，即我们所说的context classloader。这也就意味着，所有卸载掉的应用程序仍然保存在内存中。怎么解决？如果是你的程序开启了新线程，那么你就应该在卸载的时候关闭它们，这可以通过使用一个servlet context listener来实现。如果是第三方库开启的新线程，你应该搜索它的关闭线程的接口，如果没有的话，就上报一个bug吧。
文章来源：http://www.codelast.com/

Leaking Drivers

驱动内存泄漏

Another typical case of a leak can be caused by database drivers. We have encountered this leak in our own demo application that we ship with Plumbr. It is a slightly modified Pet Clinic application shipped along with Spring MVC. Let us highlight some things that happen when this application is being deployed to the server.
另一个典型的内存泄漏原因是由数据库驱动造成的。我们在和Plumbr一起发布的demo程序中遇到了这种内存泄漏情况。它是一个与Sprint MVC一起发布的、代码稍微修改过的Pet Clinic程序。让我们关注一下当这个应用程序部署到服务器上的时候，发生了什么：

• The server creates a new instance of java.lang.Classloader and starts to load the application’s classes using it.
• 服务器创建一个java.lang.Classloader的新实例，并用它来加载程序的类。
• Since the PetClinic uses a HSQL database, it loads the corresponding JDBC driver,org.hsqldb.jdbcDriver
• 由于PetClinic使用了HSQL数据库，所以它会加载相应的JDBC驱动，即org.hsqldb.jdbcDriver
• This class, being a good-mannered JDBC driver, registers itself with java.sql.DriverManager during initialization, as required per JDBC specification. This registration includes storing inside a static field of DriverManager a reference to an instance of org.hsqldb.jdbcDriver.
• 这个JDBC驱动类会在初始化的时候将它注册到java.sql.DriverManager中（正如JDBC规范所要求的那样）。这个注册过程包括了存储org.hsqldb.jdbcDriver的一个实例的引用到DriverManager的一个静态域中

Now, when the application is undeployed from the application server, the java.sql.DriverManager will still hold that reference, as there is no code in the HSQLDB library nor in the Spring framework nor in the application to remove that! As was explained above, a jdbcDriver object still holds a reference to anorg.hsqldb.jdbcDriver class, which in turn holds a reference to the instance of java.lang.Classloaderused to load the application. This classloader now still reference all the classes of the application. In case of our particular demo application, during application startup almost 2000 classes are loaded, occupying roughly 10MB in PermGen. Which means that it takes about 5-10 redeploys to fill the PermGen with default size to reach the java.lang.OutOfMemoryError: PermGen space crash.
现在，当从服务器上卸载应用程序的时候，java.sql.DriverManager仍将持有那个引用，无论在HSQLDB库，或者在Spring framework中，都没有代码可以移除它！正如上面解释的那样，一个jdbcDriver对象将持有一个到org.hsqldb.jdbcDriver类的引用，从而持有用于加载应用程序的java.lang.Classloader的一个实例的引用。这个classloader现在仍然引用着应用程序的所有类。在我们那特殊的demo应用程序中，在程序启动的时候，需要加载将近2000个类，占用约10MB永久代（PermGen）内存。这就意味着需要5~10次重新部署，才会将默认大小的永久代（PermGen）塞满，然后就会触发java.lang.OutOfMemoryError: PermGen space错误并崩溃。

How to fix that? One possibility is to write a servlet context listener, which de-registers the HSQLDB driver from DriverManager during application shutdown. This is pretty straightforward. But remember – you will have to write the corresponding code in every application using the driver.
怎样解决此问题？一个可能的办法就是写一个servlet content listener，用于在应用程序关闭的时候，从DriverManager反注册HSQLDB驱动。这个方法很直接，但是请记住——你需要在使用该驱动的每一个应用程序中都这么写。

Download our latest version of Plumbr with our demo application and play with it to find out how the leak occurs, how Plumbr finds it and how do we explain the cause.
下载我们最新版的Plumbr以及demo应用程序来研究一下，看看内存泄漏是怎么发生的，Plumbr是怎么发现它，以及我们是怎么解释其原因的。
文章来源：http://www.codelast.com/

Conclusion

结论

There are many reasons why your application might encounter a java.lang.OutOfMemoryError: PermGen space. The root cause for the majority of them is some reference to an object or a class loaded by the application’s class loader that has died after that. Or a direct link to the class loader itself. The actions you need to take for remedy are quite similar for most of these causes. Firstly, find out where that reference is being held. Secondly, add a shutdown hook to your web application to remove the reference during application’s undeployment. You can do that by either using a servlet context listener or by using the API provided by your 3rd party library.
你的应用程序遇到java.lang.OutOfMemoryError: PermGen space错误的原因很多，究其根本原因，大多数是由于object或程序的class loader加载的类的引用已经无用了导致的。对此类问题，你需要采取的补救措施都非常相似，即，首先，找出引用在哪里被持有；其次，给你的web应用程序添加一个关闭的hook，或者在应用程序卸载后移除引用。你要么通过servlet context listener，要么通过第三方库提供的API来实现这一点。

Finding those leaking references has never been easy. We ourselves have spent countless hours trying to trace down why some applications require 20MB of PermGen on each redeploy. But as of version 1.1,, Plumbr will show you the cause of the leak and give you a hint on how to fix it. If you want to try it out, register and download the tool. If you are running an older version of Plumbr, we strongly recommend downloading an upgrade.
找出内存泄漏的引用从来就不是件容易事。例如，就我们自己来说，我们曾经花费了数不清的时间去追踪为什么某些程序每一次部署都需要用掉20MB的永久代（PermGen）内存。但是，Plumbr 1.1版能告诉你内存泄漏的原因，并给出修复提示。如果你想试试，就去注册下载吧。如果你还在使用旧版的Plumbr，我们强烈建议你升级到新版。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

String configFileName = "config.properties";
Properties properties = new Properties();
properties.load(MyClass.class.getClassLoader().getResourceAsStream(configFileName));

上面的代码中仅使用了配置文件名，而不是其完整路径，这就导致了可能在IntelliJ中运行一个单独的单元测试的时候，找不到该配置文件，因为你只提供文件名的话，该文件必须要在classpath中，否则是找不到它的。

所以，我们可以把该配置文件所在的目录添加到IntelliJ项目里的classpath中，让它可以在运行单元测试的时候找得到。方法如下（一图胜千言，直接看下面的演示图就明白了）：
文章来源：http://www.codelast.com/
点击菜单File→Project Structure，进入“Project Structure”对话框，点击左侧的“Modules”，然后点击中部的“Dependencies”tab，然后再点击右部的“+”号添加你指定的目录，这里要注意了，在弹出的“Attach Files”对话框中，你必须要选择“classes”（如图所示）。最后，把目录添加进来之后，再把它们对应的“Scope”设置为“Test”，表示在测试中会依赖这个目录，即可。

图片可保存下来放大查看。

以上方法在IntelliJ 12.0.4中亲测通过，对于其他版本的IntelliJ也应该类似。

【补充】
12.1.4版的IntelliJ与上面的图略有不同。在点击了“+”号之后，会弹出一个菜单：

选择“Jars or directories...”，然后会弹出对话框让你选择目录或文件，选择好之后，和上面一样，要选择“classes”，后面的操作也一样了。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：