Checks if a CharSequence is empty ("") or null.
+ * + *
+ * StringUtils.isEmpty(null) = true
+ * StringUtils.isEmpty("") = true
+ * StringUtils.isEmpty(" ") = false
+ * StringUtils.isEmpty("bob") = false
+ * StringUtils.isEmpty(" bob ") = false
+ *
+ *
+ * NOTE: This method changed in Lang version 2.0. + * It no longer trims the CharSequence. + * That functionality is available in isBlank().
+ * + * @param cs the CharSequence to check, may be null + * @return {@code true} if the CharSequence is empty or null + * @since 3.0 Changed signature from isEmpty(String) to isEmpty(CharSequence) + */ + public static boolean isEmpty(CharSequence cs) { + return cs == null || cs.length() == 0; + } + + /** + * Used by the indexOf(CharSequence methods) as a green implementation of indexOf. + * + * @param cs the {@code CharSequence} to be processed + * @param searchChar the {@code CharSequence} to be searched for + * @param start the start index + * @return the index where the search sequence was found + */ + static int indexOf(CharSequence cs, CharSequence searchChar, int start) { + return cs.toString().indexOf(searchChar.toString(), start); + } + + /** + *Counts how many times the substring appears in the larger string.
+ * + *A {@code null} or empty ("") String input returns {@code 0}.
+ * + *
+ * StringUtils.countMatches(null, *) = 0
+ * StringUtils.countMatches("", *) = 0
+ * StringUtils.countMatches("abba", null) = 0
+ * StringUtils.countMatches("abba", "") = 0
+ * StringUtils.countMatches("abba", "a") = 2
+ * StringUtils.countMatches("abba", "ab") = 1
+ * StringUtils.countMatches("abba", "xxx") = 0
+ *
+ *
+ * @param str the CharSequence to check, may be null
+ * @param sub the substring to count, may be null
+ * @return the number of occurrences, 0 if either CharSequence is {@code null}
+ * @since 3.0 Changed signature from countMatches(String, String) to countMatches(CharSequence, CharSequence)
+ */
+ public static int countMatches(CharSequence str, CharSequence sub) {
+ if (isEmpty(str) || isEmpty(sub)) {
+ return 0;
+ }
+ int count = 0;
+ int idx = 0;
+ while ((idx = indexOf(str, sub, idx)) != -1) {
+ count++;
+ idx += sub.length();
+ }
+ return count;
+ }
+
+ //---------------------------------------------------------
+ //
+ // Validators
+ //
+ //---------------------------------------------------------
+
+ /**
+ * Validate that the specified argument is not {@code null}; + * otherwise throwing an exception with the specified message. + * + *
Validate.notNull(myObject, "The object must not be null");+ * + * @param
Validate that the argument condition is {@code true}; otherwise + * throwing an exception with the specified message. This method is useful when + * validating according to an arbitrary boolean expression, such as validating a + * primitive number or using your own custom validation expression.
+ * + *Validate.isTrue(i > 0.0, "The value must be greater than zero: %d", i);+ * + *
For performance reasons, the long value is passed as a separate parameter and + * appended to the exception message only in the case of an error.
+ * + * @param expression the boolean expression to check + * @param message + * @throws IllegalArgumentException if expression is {@code false} + */ + public static void isTrue(boolean expression, String message) { + if (expression == false) { + throw new IllegalArgumentException(message); + } + } + + /** + *Validate that the specified argument character sequence is + * neither {@code null} nor a length of zero (no characters); + * otherwise throwing an exception with the specified message. + * + *
Validate.notEmpty(myString, "The string must not be empty");+ * + * @param
Deep clone an {@code Object} using serialization.
+ * + *This is many times slower than writing clone methods by hand + * on all objects in your object graph. However, for complex object + * graphs, or for those that don't support deep cloning this can + * be a simple alternative implementation. Of course all the objects + * must be {@code Serializable}.
+ * + * @paramSerializes an {@code Object} to the specified stream.
+ * + *The stream will be closed once the object is written. + * This avoids the need for a finally clause, and maybe also exception + * handling, in the application code.
+ * + *The stream passed in is not buffered internally within this method. + * This is the responsibility of your application if desired.
+ * + * @param obj the object to serialize to bytes, may be null + * @param outputStream the stream to write to, must not be null + * @throws IllegalArgumentException if {@code outputStream} is {@code null} + * @throws RuntimeException (runtime) if the serialization fails + */ + public static void serialize(Serializable obj, OutputStream outputStream) { + if (outputStream == null) { + throw new IllegalArgumentException("The OutputStream must not be null"); + } + ObjectOutputStream out = null; + try { + // stream closed in the finally + out = new ObjectOutputStream(outputStream); + out.writeObject(obj); + + } catch (IOException ex) { + throw new RuntimeException(ex); + } finally { + try { + if (out != null) { + out.close(); + } + } catch (IOException ex) { // NOPMD + // ignore close exception + } + } + } + + /** + *Serializes an {@code Object} to a byte array for + * storage/serialization.
+ * + * @param obj the object to serialize to bytes + * @return a byte[] with the converted Serializable + * @throws RuntimeException (runtime) if the serialization fails + */ + public static byte[] serialize(Serializable obj) { + ByteArrayOutputStream baos = new ByteArrayOutputStream(512); + serialize(obj, baos); + return baos.toByteArray(); + } + + // Deserialize + //----------------------------------------------------------------------- + /** + *Deserializes an {@code Object} from the specified stream.
+ * + *The stream will be closed once the object is written. This + * avoids the need for a finally clause, and maybe also exception + * handling, in the application code.
+ * + *The stream passed in is not buffered internally within this method. + * This is the responsibility of your application if desired.
+ * + * @param inputStream the serialized object input stream, must not be null + * @return the deserialized object + * @throws IllegalArgumentException if {@code inputStream} is {@code null} + * @throws RuntimeException (runtime) if the serialization fails + */ + public static Object deserialize(InputStream inputStream) { + if (inputStream == null) { + throw new IllegalArgumentException("The InputStream must not be null"); + } + ObjectInputStream in = null; + try { + // stream closed in the finally + in = new ObjectInputStream(inputStream); + return in.readObject(); + + } catch (ClassNotFoundException ex) { + throw new RuntimeException(ex); + } catch (IOException ex) { + throw new RuntimeException(ex); + } finally { + try { + if (in != null) { + in.close(); + } + } catch (IOException ex) { // NOPMD + // ignore close exception + } + } + } + + /** + *Deserializes a single {@code Object} from an array of bytes.
+ * + * @param objectData the serialized object, must not be null + * @return the deserialized object + * @throws IllegalArgumentException if {@code objectData} is {@code null} + * @throws RuntimeException (runtime) if the serialization fails + */ + public static Object deserialize(byte[] objectData) { + if (objectData == null) { + throw new IllegalArgumentException("The byte[] must not be null"); + } + ByteArrayInputStream bais = new ByteArrayInputStream(objectData); + return deserialize(bais); + } + + /** + *Custom specialization of the standard JDK {@link java.io.ObjectInputStream}
+ * that uses a custom ClassLoader to resolve a class.
+ * If the specified ClassLoader is not able to resolve the class,
+ * the context classloader of the current thread will be used.
+ * This way, the standard deserialization work also in web-application
+ * containers and application servers, no matter in which of the
+ * ClassLoader the particular class that encapsulates
+ * serialization/deserialization lives.
For more in-depth information about the problem for which this + * class here is a workaround, see the JIRA issue LANG-626.
+ */ + static class ClassLoaderAwareObjectInputStream extends ObjectInputStream { + private ClassLoader classLoader; + + /** + * Constructor. + * @param in TheInputStream.
+ * @param classLoader classloader to use
+ * @throws IOException if an I/O error occurs while reading stream header.
+ * @see java.io.ObjectInputStream
+ */
+ public ClassLoaderAwareObjectInputStream(InputStream in, ClassLoader classLoader) throws IOException {
+ super(in);
+ this.classLoader = classLoader;
+ }
+
+ /**
+ * Overriden version that uses the parametrized ClassLoader or the ClassLoader
+ * of the current Thread to resolve the class.
+ * @param desc An instance of class ObjectStreamClass.
+ * @return A Class object corresponding to desc.
+ * @throws IOException Any of the usual Input/Output exceptions.
+ * @throws ClassNotFoundException If class of a serialized object cannot be found.
+ */
+ @Override
+ protected Class resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
+ String name = desc.getName();
+ try {
+ return Class.forName(name, false, classLoader);
+ } catch (ClassNotFoundException ex) {
+ return Class.forName(name, false, Thread.currentThread().getContextClassLoader());
+ }
+ }
+
+ }
+}
diff --git a/json-path/src/main/java/com/jayway/jsonpath/spi/impl/AbstractJsonProvider.java b/json-path/src/main/java/com/jayway/jsonpath/spi/impl/AbstractJsonProvider.java
index 7fc9adac..d35e5702 100644
--- a/json-path/src/main/java/com/jayway/jsonpath/spi/impl/AbstractJsonProvider.java
+++ b/json-path/src/main/java/com/jayway/jsonpath/spi/impl/AbstractJsonProvider.java
@@ -14,8 +14,8 @@
*/
package com.jayway.jsonpath.spi.impl;
+import com.jayway.jsonpath.internal.Utils;
import com.jayway.jsonpath.spi.JsonProvider;
-import org.apache.commons.lang3.SerializationUtils;
import java.io.Serializable;
import java.util.ArrayList;
@@ -30,7 +30,7 @@ public abstract class AbstractJsonProvider implements JsonProvider {
@Override
public Object clone(Object obj){
- return SerializationUtils.clone((Serializable)obj);
+ return Utils.clone((Serializable) obj);
}
/**
diff --git a/json-path/src/test/java/com/jayway/jsonpath/HttpProviderTest.java b/json-path/src/test/java/com/jayway/jsonpath/HttpProviderTest.java
index dac8704d..f2c6651b 100644
--- a/json-path/src/test/java/com/jayway/jsonpath/HttpProviderTest.java
+++ b/json-path/src/test/java/com/jayway/jsonpath/HttpProviderTest.java
@@ -1,8 +1,7 @@
package com.jayway.jsonpath;
-import com.jayway.jsonpath.internal.IOUtils;
+import com.jayway.jsonpath.internal.Utils;
import com.jayway.jsonpath.spi.HttpProviderFactory;
-import org.junit.Ignore;
import org.junit.Test;
import java.io.IOException;
@@ -42,7 +41,7 @@ public class HttpProviderTest {
assertEquals(EXPECTED, json);
} catch (IOException e) {
- IOUtils.closeQuietly(inputStream);
+ Utils.closeQuietly(inputStream);
}
}
diff --git a/json-path/src/test/java/com/jayway/jsonpath/IssuesTest.java b/json-path/src/test/java/com/jayway/jsonpath/IssuesTest.java
index f30a90ea..937b2cdc 100644
--- a/json-path/src/test/java/com/jayway/jsonpath/IssuesTest.java
+++ b/json-path/src/test/java/com/jayway/jsonpath/IssuesTest.java
@@ -1,11 +1,9 @@
package com.jayway.jsonpath;
-import com.jayway.jsonpath.internal.IOUtils;
-
+import com.jayway.jsonpath.internal.Utils;
import net.minidev.json.JSONObject;
import org.hamcrest.Matchers;
-import org.junit.Ignore;
import org.junit.Test;
import java.io.InputStream;
@@ -109,7 +107,7 @@ public class IssuesTest {
is.close();
} catch (Exception e) {
e.printStackTrace();
- IOUtils.closeQuietly(is);
+ Utils.closeQuietly(is);
}
}
diff --git a/json-path/src/test/java/com/jayway/jsonpath/JsonProviderTest.java b/json-path/src/test/java/com/jayway/jsonpath/JsonProviderTest.java
index 97949795..0112daff 100644
--- a/json-path/src/test/java/com/jayway/jsonpath/JsonProviderTest.java
+++ b/json-path/src/test/java/com/jayway/jsonpath/JsonProviderTest.java
@@ -1,7 +1,7 @@
package com.jayway.jsonpath;
+import com.jayway.jsonpath.internal.Utils;
import com.jayway.jsonpath.spi.impl.JacksonProvider;
-import org.apache.commons.lang3.SerializationUtils;
import org.junit.Test;
import java.io.Serializable;
@@ -60,7 +60,7 @@ public class JsonProviderTest {
Serializable jsonObject = (Serializable) model(DOCUMENT).getJsonObject();
- Object clone = SerializationUtils.clone(jsonObject);
+ Object clone = Utils.clone(jsonObject);
System.out.println(model(clone).toJson());
diff --git a/pom.xml b/pom.xml
index 50c83fd6..9e3c2890 100644
--- a/pom.xml
+++ b/pom.xml
@@ -59,7 +59,6 @@