Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 gobblin.util.guid; import lombok.EqualsAndHashCode; import java.io.IOException; import org.apache.commons.codec.DecoderException; import org.apache.commons.codec.binary.Hex; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang3.ArrayUtils; import com.google.common.base.Charsets; /** * Class wrapping a byte array representing a guid. A {@link Guid} is intended to uniquely identify objects in a * replicable way. */ @EqualsAndHashCode public class Guid { public static final int GUID_LENGTH = 20; final byte[] sha; /** * Creates a {@link Guid} by computing the sha of the input bytes. */ public Guid(byte[] bytes) { this(bytes, false); } /** * @param bytes byte array. * @param isSha true if bytes are already a sha. */ private Guid(byte[] bytes, boolean isSha) { if (isSha) { this.sha = bytes; } else { this.sha = computeGuid(bytes); } } /** * Generate a {@link Guid} for an array of {@link HasGuid}. * @param objs array of {@link HasGuid}. * @return a single {@link Guid} for the array. * @throws IOException */ public static Guid fromHasGuid(HasGuid... objs) throws IOException { byte[][] byteArrays = new byte[objs.length][]; for (int i = 0; i < objs.length; i++) { byteArrays[i] = objs[i].guid().sha; } return fromByteArrays(byteArrays); } /** * Generate a {@link Guid} for an array of Strings. * @param strings array of Strings. * @return a single {@link Guid} for the array. * @throws IOException */ public static Guid fromStrings(String... strings) throws IOException { if (strings == null || strings.length == 0) { throw new IOException("Attempting to compute guid for an empty array."); } return new Guid(StringUtils.join(strings).getBytes(Charsets.UTF_8)); } /** * Generate a {@link Guid} for an array of byte arrays. * @param byteArrays array of byte arrays. * @return a single {@link Guid} for the array. * @throws IOException */ public static Guid fromByteArrays(byte[]... byteArrays) throws IOException { if (byteArrays == null || byteArrays.length == 0) { throw new IOException("Attempting to compute guid for an empty array."); } if (byteArrays.length == 1) { return new Guid(byteArrays[0]); } byte[] tmp = new byte[0]; for (byte[] arr : byteArrays) { tmp = ArrayUtils.addAll(tmp, arr); } return new Guid(tmp); } /** * Reverse of {@link #toString}. Deserializes a {@link Guid} from a previously serialized one. * @param str Serialized {@link Guid}. * @return deserialized {@link Guid}. * @throws IOException */ public static Guid deserialize(String str) throws IOException { if (str.length() != 2 * GUID_LENGTH) { throw new IOException("String is not an encoded guid."); } try { return new Guid(Hex.decodeHex(str.toCharArray()), true); } catch (DecoderException de) { throw new IOException(de); } } /** * Combine multiple {@link Guid}s into a single {@link Guid}. * @throws IOException */ public static Guid combine(Guid... guids) throws IOException { byte[][] byteArrays = new byte[guids.length][]; for (int i = 0; i < guids.length; i++) { byteArrays[i] = guids[i].sha; } return fromByteArrays(byteArrays); } /** * Creates a new {@link Guid} which is a unique, replicable representation of the pair (this, byteArrays). * @param byteArrays an array of byte arrays. * @return a new {@link Guid}. * @throws IOException */ public Guid append(byte[]... byteArrays) throws IOException { if (byteArrays == null || byteArrays.length == 0) { return this; } return fromByteArrays(ArrayUtils.add(byteArrays, this.sha)); } /** * Creates a new {@link Guid} which is a unique, replicable representation of the pair (this, guids). Equivalent to * combine(this, guid1, guid2, ...) * @param guids an array of {@link Guid}. * @return a new {@link Guid}. * @throws IOException */ public Guid append(Guid... guids) throws IOException { if (guids == null || guids.length == 0) { return this; } return combine(ArrayUtils.add(guids, this)); } /** * Creates a new {@link Guid} which is a unique, replicable representation of the pair (this, objs). * @param objs an array of {@link HasGuid}. * @return a new {@link Guid}. * @throws IOException */ public Guid append(HasGuid... objs) throws IOException { if (objs == null || objs.length == 0) { return this; } return fromHasGuid(ArrayUtils.add(objs, new SimpleHasGuid(this))); } /** * Serializes the guid into a hex string. The original {@link Guid} can be recovered using {@link #deserialize}. */ @Override public String toString() { return Hex.encodeHexString(this.sha); } // DigestUtils.sha is deprecated for sha1, but sha1 is not available in old versions of commons codec @SuppressWarnings("deprecation") private static byte[] computeGuid(byte[] bytes) { return DigestUtils.sha(bytes); } static class SimpleHasGuid implements HasGuid { private final Guid guid; public SimpleHasGuid(Guid guid) { this.guid = guid; } @Override public Guid guid() throws IOException { return this.guid; } } }