iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'eugenp:master' into master

This commit is contained in:
Ashish Gupta 2021-10-18 10:30:15 +05:30 committed by GitHub
parent 1afa3bfcea 125aa509c0
commit 88261b4340
36 changed files with 913 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
core-java-modules/core-java-arrays-convert/pom.xml
View File

@ -19,6 +19,11 @@
<artifactId>guava</artifactId>
<version>${guava.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3.version}</version>
</dependency>
</dependencies>
<properties>

281
core-java-modules/core-java-arrays-convert/src/main/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentation.java Normal file
View File

@ -0,0 +1,281 @@
package com.baeldung.array.conversions;
import com.google.common.primitives.Ints;
import com.google.common.primitives.Longs;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.Conversion;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.util.Arrays;
class ByteArrayToNumericRepresentation {
static int convertByteArrayToIntUsingShiftOperator(byte[] bytes) {
int value = 0;
for (byte b : bytes) {
value = (value << 8) + (b & 0xFF);
}
return value;
}
static byte[] convertIntToByteArrayUsingShiftOperator(int value) {
byte[] bytes = new byte[Integer.BYTES];
int length = bytes.length;
for (int i = 0; i < length; i++) {
bytes[length - i - 1] = (byte) (value & 0xFF);
value >>= 8;
}
return bytes;
}
static long convertByteArrayToLongUsingShiftOperator(byte[] bytes) {
long value = 0;
for (byte b : bytes) {
value <<= 8;
value |= (b & 0xFF);
}
return value;
}
static byte[] convertLongToByteArrayUsingShiftOperator(long value) {
byte[] bytes = new byte[Long.BYTES];
int length = bytes.length;
for (int i = 0; i < length; i++) {
bytes[length - i - 1] = (byte) (value & 0xFF);
value >>= 8;
}
return bytes;
}
static float convertByteArrayToFloatUsingShiftOperator(byte[] bytes) {
// convert bytes to int
int intValue = 0;
for (byte b : bytes) {
intValue = (intValue << 8) + (b & 0xFF);
}
// convert int to float
return Float.intBitsToFloat(intValue);
}
static byte[] convertFloatToByteArrayUsingShiftOperator(float value) {
// convert float to int
int intValue = Float.floatToIntBits(value);
// convert int to bytes
byte[] bytes = new byte[Float.BYTES];
int length = bytes.length;
for (int i = 0; i < length; i++) {
bytes[length - i - 1] = (byte) (intValue & 0xFF);
intValue >>= 8;
}
return bytes;
}
static double convertingByteArrayToDoubleUsingShiftOperator(byte[] bytes) {
long longValue = 0;
for (byte b : bytes) {
longValue = (longValue << 8) + (b & 0xFF);
}
return Double.longBitsToDouble(longValue);
}
static byte[] convertDoubleToByteArrayUsingShiftOperator(double value) {
long longValue = Double.doubleToLongBits(value);
byte[] bytes = new byte[Double.BYTES];
int length = bytes.length;
for (int i = 0; i < length; i++) {
bytes[length - i - 1] = (byte) (longValue & 0xFF);
longValue >>= 8;
}
return bytes;
}
static int convertByteArrayToIntUsingByteBuffer(byte[] bytes) {
ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
buffer.put(bytes);
buffer.rewind();
return buffer.getInt();
}
static byte[] convertIntToByteArrayUsingByteBuffer(int value) {
ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
buffer.putInt(value);
buffer.rewind();
return buffer.array();
}
static long convertByteArrayToLongUsingByteBuffer(byte[] bytes) {
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.put(bytes);
buffer.rewind();
return buffer.getLong();
}
static byte[] convertLongToByteArrayUsingByteBuffer(long value) {
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.putLong(value);
buffer.rewind();
return buffer.array();
}
static float convertByteArrayToFloatUsingByteBuffer(byte[] bytes) {
ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
buffer.put(bytes);
buffer.rewind();
return buffer.getFloat();
}
static byte[] convertFloatToByteArrayUsingByteBuffer(float value) {
ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
buffer.putFloat(value);
buffer.rewind();
return buffer.array();
}
static double convertByteArrayToDoubleUsingByteBuffer(byte[] bytes) {
ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
buffer.put(bytes);
buffer.rewind();
return buffer.getDouble();
}
static byte[] convertDoubleToByteArrayUsingByteBuffer(double value) {
ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
buffer.putDouble(value);
buffer.rewind();
return buffer.array();
}
static int convertByteArrayToIntUsingBigInteger(byte[] bytes) {
return new BigInteger(bytes).intValue();
}
static byte[] convertIntToByteArrayUsingBigInteger(int value) {
return BigInteger.valueOf(value).toByteArray();
}
static long convertByteArrayToLongUsingBigInteger(byte[] bytes) {
return new BigInteger(bytes).longValue();
}
static byte[] convertLongToByteArrayUsingBigInteger(long value) {
return BigInteger.valueOf(value).toByteArray();
}
static float convertByteArrayToFloatUsingBigInteger(byte[] bytes) {
int intValue = new BigInteger(bytes).intValue();
return Float.intBitsToFloat(intValue);
}
static byte[] convertFloatToByteArrayUsingBigInteger(float value) {
int intValue = Float.floatToIntBits(value);
return BigInteger.valueOf(intValue).toByteArray();
}
static double convertByteArrayToDoubleUsingBigInteger(byte[] bytes) {
long longValue = new BigInteger(bytes).longValue();
return Double.longBitsToDouble(longValue);
}
static byte[] convertDoubleToByteArrayUsingBigInteger(double value) {
long longValue = Double.doubleToLongBits(value);
return BigInteger.valueOf(longValue).toByteArray();
}
static int convertingByteArrayToIntUsingGuava(byte[] bytes) {
return Ints.fromByteArray(bytes);
}
static byte[] convertIntToByteArrayUsingGuava(int value) {
return Ints.toByteArray(value);
}
static long convertByteArrayToLongUsingGuava(byte[] bytes) {
return Longs.fromByteArray(bytes);
}
static byte[] convertLongToByteArrayUsingGuava(long value) {
return Longs.toByteArray(value);
}
static float convertByteArrayToFloatUsingGuava(byte[] bytes) {
int intValue = Ints.fromByteArray(bytes);
return Float.intBitsToFloat(intValue);
}
static byte[] convertFloatToByteArrayUsingGuava(float value) {
int intValue = Float.floatToIntBits(value);
return Ints.toByteArray(intValue);
}
static double convertByteArrayToDoubleUsingGuava(byte[] bytes) {
long longValue = Longs.fromByteArray(bytes);
return Double.longBitsToDouble(longValue);
}
static byte[] convertDoubleToByteArrayUsingGuava(double value) {
long longValue = Double.doubleToLongBits(value);
return Longs.toByteArray(longValue);
}
static int convertByteArrayToIntUsingCommonsLang(byte[] bytes) {
byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
ArrayUtils.reverse(copyBytes);
return Conversion.byteArrayToInt(copyBytes, 0, 0, 0, copyBytes.length);
}
static byte[] convertIntToByteArrayUsingCommonsLang(int value) {
byte[] bytes = new byte[Integer.BYTES];
Conversion.intToByteArray(value, 0, bytes, 0, bytes.length);
ArrayUtils.reverse(bytes);
return bytes;
}
static long convertByteArrayToLongUsingCommonsLang(byte[] bytes) {
byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
ArrayUtils.reverse(copyBytes);
return Conversion.byteArrayToLong(copyBytes, 0, 0, 0, copyBytes.length);
}
static byte[] convertLongToByteArrayUsingCommonsLang(long value) {
byte[] bytes = new byte[Long.BYTES];
Conversion.longToByteArray(value, 0, bytes, 0, bytes.length);
ArrayUtils.reverse(bytes);
return bytes;
}
static float convertByteArrayToFloatUsingCommonsLang(byte[] bytes) {
byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
ArrayUtils.reverse(copyBytes);
int intValue = Conversion.byteArrayToInt(copyBytes, 0, 0, 0, copyBytes.length);
return Float.intBitsToFloat(intValue);
}
static byte[] convertFloatToByteArrayUsingCommonsLang(float value) {
int intValue = Float.floatToIntBits(value);
byte[] bytes = new byte[Float.BYTES];
Conversion.intToByteArray(intValue, 0, bytes, 0, bytes.length);
ArrayUtils.reverse(bytes);
return bytes;
}
static double convertByteArrayToDoubleUsingCommonsLang(byte[] bytes) {
byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
ArrayUtils.reverse(copyBytes);
long longValue = Conversion.byteArrayToLong(copyBytes, 0, 0, 0, copyBytes.length);
return Double.longBitsToDouble(longValue);
}
static byte[] convertDoubleToByteArrayUsingCommonsLang(double value) {
long longValue = Double.doubleToLongBits(value);
byte[] bytes = new byte[Long.BYTES];
Conversion.longToByteArray(longValue, 0, bytes, 0, bytes.length);
ArrayUtils.reverse(bytes);
return bytes;
}
}

316
core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentationUnitTest.java Normal file
View File

@ -0,0 +1,316 @@
package com.baeldung.array.conversions;
import org.junit.Test;
import static com.baeldung.array.conversions.ByteArrayToNumericRepresentation.*;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
public class ByteArrayToNumericRepresentationUnitTest {
private static final byte[] INT_BYTE_ARRAY = new byte[]{
(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE
};
private static final int INT_VALUE = 0xCAFEBABE;
private static final byte[] FLOAT_BYTE_ARRAY = new byte[]{
(byte) 0x40, (byte) 0x48, (byte) 0xF5, (byte) 0xC3
};
private static final float FLOAT_VALUE = 3.14F;
private static final byte[] LONG_BYTE_ARRAY = new byte[]{
(byte) 0x01, (byte) 0x23, (byte) 0x45, (byte) 0x67,
(byte) 0x89, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF
};
private static final long LONG_VALUE = 0x0123456789ABCDEFL;
private static final byte[] DOUBLE_BYTE_ARRAY = new byte[]{
(byte) 0x3F, (byte) 0xE3, (byte) 0xC6, (byte) 0xA7,
(byte) 0xEF, (byte) 0x9D, (byte) 0xB2, (byte) 0x2D
};
private static final double DOUBLE_VALUE = 0.618D;
@Test
public void givenShiftOperator_whenConvertingByteArrayToInt_thenSuccess() {
int value = convertByteArrayToIntUsingShiftOperator(INT_BYTE_ARRAY);
assertEquals(INT_VALUE, value);
}
@Test
public void givenShiftOperator_whenConvertingIntToByteArray_thenSuccess() {
byte[] bytes = convertIntToByteArrayUsingShiftOperator(INT_VALUE);
assertArrayEquals(INT_BYTE_ARRAY, bytes);
}
@Test
public void givenShiftOperator_whenConvertingByteArrayToLong_thenSuccess() {
long value = convertByteArrayToLongUsingShiftOperator(LONG_BYTE_ARRAY);
assertEquals(LONG_VALUE, value);
}
@Test
public void givenShiftOperator_whenConvertingLongToByteArray_thenSuccess() {
byte[] bytes = convertLongToByteArrayUsingShiftOperator(LONG_VALUE);
assertArrayEquals(LONG_BYTE_ARRAY, bytes);
}
@Test
public void givenShiftOperator_whenConvertingByteArrayToFloat_thenSuccess() {
float value = convertByteArrayToFloatUsingShiftOperator(FLOAT_BYTE_ARRAY);
assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
}
@Test
public void givenShiftOperator_whenConvertingFloatToByteArray_thenSuccess() {
byte[] bytes = convertFloatToByteArrayUsingShiftOperator(FLOAT_VALUE);
assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
}
@Test
public void givenShiftOperator_whenConvertingByteArrayToDouble_thenSuccess() {
double value = convertingByteArrayToDoubleUsingShiftOperator(DOUBLE_BYTE_ARRAY);
assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
}
@Test
public void givenShiftOperator_whenConvertingDoubleToByteArray_thenSuccess() {
byte[] bytes = convertDoubleToByteArrayUsingShiftOperator(DOUBLE_VALUE);
assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
}
@Test
public void givenByteBuffer_whenConvertingByteArrayToInt_thenSuccess() {
int value = convertByteArrayToIntUsingByteBuffer(INT_BYTE_ARRAY);
assertEquals(INT_VALUE, value);
}
@Test
public void givenByteBuffer_whenConvertingIntToByteArray_thenSuccess() {
byte[] bytes = convertIntToByteArrayUsingByteBuffer(INT_VALUE);
assertArrayEquals(INT_BYTE_ARRAY, bytes);
}
@Test
public void givenByteBuffer_whenConvertingByteArrayToLong_thenSuccess() {
long value = convertByteArrayToLongUsingByteBuffer(LONG_BYTE_ARRAY);
assertEquals(LONG_VALUE, value);
}
@Test
public void givenByteBuffer_whenConvertingLongToByteArray_thenSuccess() {
byte[] bytes = convertLongToByteArrayUsingByteBuffer(LONG_VALUE);
assertArrayEquals(LONG_BYTE_ARRAY, bytes);
}
@Test
public void givenByteBuffer_whenConvertingByteArrayToFloat_thenSuccess() {
float value = convertByteArrayToFloatUsingByteBuffer(FLOAT_BYTE_ARRAY);
assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
}
@Test
public void givenByteBuffer_whenConvertingFloatToByteArray_thenSuccess() {
byte[] bytes = convertFloatToByteArrayUsingByteBuffer(FLOAT_VALUE);
assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
}
@Test
public void givenByteBuffer_whenConvertingByteArrayToDouble_thenSuccess() {
double value = convertByteArrayToDoubleUsingByteBuffer(DOUBLE_BYTE_ARRAY);
assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
}
@Test
public void givenByteBuffer_whenConvertingDoubleToByteArray_thenSuccess() {
byte[] bytes = convertDoubleToByteArrayUsingByteBuffer(DOUBLE_VALUE);
assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
}
@Test
public void givenBigInteger_whenConvertingByteArrayToInt_thenSuccess() {
int value = convertByteArrayToIntUsingBigInteger(INT_BYTE_ARRAY);
assertEquals(INT_VALUE, value);
}
@Test
public void givenBigInteger_whenConvertingIntToByteArray_thenSuccess() {
byte[] bytes = convertIntToByteArrayUsingBigInteger(INT_VALUE);
assertArrayEquals(INT_BYTE_ARRAY, bytes);
}
@Test
public void givenBigInteger_whenConvertingByteArrayToLong_thenSuccess() {
long value = convertByteArrayToLongUsingBigInteger(LONG_BYTE_ARRAY);
assertEquals(LONG_VALUE, value);
}
@Test
public void givenBigInteger_whenConvertingLongToByteArray_thenSuccess() {
byte[] bytes = convertLongToByteArrayUsingBigInteger(LONG_VALUE);
assertArrayEquals(LONG_BYTE_ARRAY, bytes);
}
@Test
public void givenBigInteger_whenConvertingByteArrayToFloat_thenSuccess() {
float value = convertByteArrayToFloatUsingBigInteger(FLOAT_BYTE_ARRAY);
assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
}
@Test
public void givenBigInteger_whenConvertingFloatToByteArray_thenSuccess() {
byte[] bytes = convertFloatToByteArrayUsingBigInteger(FLOAT_VALUE);
assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
}
@Test
public void givenBigInteger_whenConvertingByteArrayToDouble_thenSuccess() {
double value = convertByteArrayToDoubleUsingBigInteger(DOUBLE_BYTE_ARRAY);
assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
}
@Test
public void givenBigInteger_whenConvertingDoubleToByteArray_thenSuccess() {
byte[] bytes = convertDoubleToByteArrayUsingBigInteger(DOUBLE_VALUE);
assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
}
@Test
public void givenGuava_whenConvertingByteArrayToInt_thenSuccess() {
int value = convertingByteArrayToIntUsingGuava(INT_BYTE_ARRAY);
assertEquals(INT_VALUE, value);
}
@Test
public void givenGuava_whenConvertingIntToByteArray_thenSuccess() {
byte[] bytes = convertIntToByteArrayUsingGuava(INT_VALUE);
assertArrayEquals(INT_BYTE_ARRAY, bytes);
}
@Test
public void givenGuava_whenConvertingByteArrayToLong_thenSuccess() {
long value = convertByteArrayToLongUsingGuava(LONG_BYTE_ARRAY);
assertEquals(LONG_VALUE, value);
}
@Test
public void givenGuava_whenConvertingLongToByteArray_thenSuccess() {
byte[] bytes = convertLongToByteArrayUsingGuava(LONG_VALUE);
assertArrayEquals(LONG_BYTE_ARRAY, bytes);
}
@Test
public void givenGuava_whenConvertingByteArrayToFloat_thenSuccess() {
float value = convertByteArrayToFloatUsingGuava(FLOAT_BYTE_ARRAY);
assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
}
@Test
public void givenGuava_whenConvertingFloatToByteArray_thenSuccess() {
byte[] bytes = convertFloatToByteArrayUsingGuava(FLOAT_VALUE);
assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
}
@Test
public void givenGuava_whenConvertingByteArrayToDouble_thenSuccess() {
double value = convertByteArrayToDoubleUsingGuava(DOUBLE_BYTE_ARRAY);
assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
}
@Test
public void givenGuava_whenConvertingDoubleToByteArray_thenSuccess() {
byte[] bytes = convertDoubleToByteArrayUsingGuava(DOUBLE_VALUE);
assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
}
@Test
public void givenCommonsLang_whenConvertingByteArrayToInt_thenSuccess() {
int value = convertByteArrayToIntUsingCommonsLang(INT_BYTE_ARRAY);
assertEquals(INT_VALUE, value);
}
@Test
public void givenCommonsLang_whenConvertingIntToByteArray_thenSuccess() {
byte[] bytes = convertIntToByteArrayUsingCommonsLang(INT_VALUE);
assertArrayEquals(INT_BYTE_ARRAY, bytes);
}
@Test
public void givenCommonsLang_whenConvertingByteArrayToLong_thenSuccess() {
long value = convertByteArrayToLongUsingCommonsLang(LONG_BYTE_ARRAY);
assertEquals(LONG_VALUE, value);
}
@Test
public void givenCommonsLang_whenConvertingLongToByteArray_thenSuccess() {
byte[] bytes = convertLongToByteArrayUsingCommonsLang(LONG_VALUE);
assertArrayEquals(LONG_BYTE_ARRAY, bytes);
}
@Test
public void givenCommonsLang_whenConvertingByteArrayToFloat_thenSuccess() {
float value = convertByteArrayToFloatUsingCommonsLang(FLOAT_BYTE_ARRAY);
assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
}
@Test
public void givenCommonsLang_whenConvertingFloatToByteArray_thenSuccess() {
byte[] bytes = convertFloatToByteArrayUsingCommonsLang(FLOAT_VALUE);
assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
}
@Test
public void givenCommonsLang_whenConvertingByteArrayToDouble_thenSuccess() {
double value = convertByteArrayToDoubleUsingCommonsLang(DOUBLE_BYTE_ARRAY);
assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
}
@Test
public void givenCommonsLang_whenConvertingDoubleToByteArray_thenSuccess() {
byte[] bytes = convertDoubleToByteArrayUsingCommonsLang(DOUBLE_VALUE);
assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
}
}

49
core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizer.java Normal file
View File

@ -0,0 +1,49 @@
package com.baeldung.accentsanddiacriticsremoval;
import org.apache.commons.lang3.StringUtils;
import java.text.Normalizer;
import java.util.StringJoiner;
class StringNormalizer {
static String removeAccentsWithApacheCommons(String input) {
return StringUtils.stripAccents(input);
}
static String removeAccents(String input) {
return normalize(input).replaceAll("\\p{M}", "");
}
static String unicodeValueOfNormalizedString(String input) {
return toUnicode(normalize(input));
}
private static String normalize(String input) {
return input == null ? null : Normalizer.normalize(input, Normalizer.Form.NFKD);
}
private static String toUnicode(String input) {
if (input.length() == 1) {
return toUnicode(input.charAt(0));
} else {
StringJoiner stringJoiner = new StringJoiner(" ");
for (char c : input.toCharArray()) {
stringJoiner.add(toUnicode(c));
}
return stringJoiner.toString();
}
}
private static String toUnicode(char input) {
String hex = Integer.toHexString(input);
StringBuilder sb = new StringBuilder(hex);
while (sb.length() < 4) {
sb.insert(0, "0");
}
sb.insert(0, "\\u");
return sb.toString();
}
}

37
core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtils.java Normal file
View File

@ -0,0 +1,37 @@
package com.baeldung.doublequotesremoval;
import com.google.common.base.CharMatcher;
public class DoubleQuotesRemovalUtils {
public static String removeWithSubString(String input) {
if (input != null && input.length() >= 2 && input.charAt(0) == '\"'
&& input.charAt(input.length() - 1) == '\"') {
return input.substring(1, input.length() - 1);
}
return input;
}
public static String removeWithReplaceAllSimple(String input) {
if (input == null || input.isEmpty())
return input;
return input.replaceAll("\"", "");
}
public static String removeWithReplaceAllAdvanced(String input) {
if (input == null || input.isEmpty())
return input;
return input.replaceAll("^\"|\"$", "");
}
public static String removeWithGuava(String input) {
if (input == null || input.isEmpty())
return input;
return CharMatcher.is('\"').trimFrom(input);
}
}

70
core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/CollatorUnitTest.java Normal file
View File

@ -0,0 +1,70 @@
package com.baeldung.accentsanddiacriticsremoval;
import org.junit.Test;
import org.openjdk.jmh.annotations.Setup;
import java.text.Collator;
import static java.lang.Character.*;
import static java.lang.String.valueOf;
import static org.junit.Assert.assertEquals;
public class CollatorUnitTest {
private final Collator collator = Collator.getInstance();
@Setup
public void setup() {
collator.setDecomposition(2);
}
@Test
public void givenAccentedStringAndPrimaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
Collator collator = Collator.getInstance();
collator.setDecomposition(2);
collator.setStrength(0);
assertEquals(0, collator.compare("a", "a"));
assertEquals(0, collator.compare("ä", "a"));
assertEquals(0, collator.compare("A", "a"));
assertEquals(1, collator.compare("b", "a"));
assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
}
@Test
public void givenAccentedStringAndSecondaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
collator.setStrength(1);
assertEquals(1, collator.compare("ä", "a"));
assertEquals(1, collator.compare("b", "a"));
assertEquals(0, collator.compare("A", "a"));
assertEquals(0, collator.compare("a", "a"));
assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
}
@Test
public void givenAccentedStringAndTeriaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
collator.setStrength(2);
assertEquals(1, collator.compare("A", "a"));
assertEquals(1, collator.compare("ä", "a"));
assertEquals(1, collator.compare("b", "a"));
assertEquals(0, collator.compare("a", "a"));
assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
}
@Test
public void givenAccentedStringAndIdenticalCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
collator.setStrength(3);
assertEquals(1, collator.compare("A", "a"));
assertEquals(1, collator.compare("ä", "a"));
assertEquals(1, collator.compare("b", "a"));
assertEquals(-1, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
assertEquals(0, collator.compare("a", "a"));
}
@Test
public void givenNondecomposableAccentedStringAndIdenticalCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
collator.setStrength(0);
assertEquals(1, collator.compare("ł", "l"));
assertEquals(1, collator.compare("ø", "o"));
}
}

51
core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizerUnitTest.java Normal file
View File

@ -0,0 +1,51 @@
package com.baeldung.accentsanddiacriticsremoval;
import static org.junit.Assert.assertFalse;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.text.Normalizer;
import org.junit.jupiter.api.Test;
class StringNormalizerUnitTest {
@Test
public void givenNotNormalizedString_whenIsNormalized_thenReturnFalse() {
assertFalse(Normalizer.isNormalized("āăąēîïĩíĝġńñšŝśûůŷ", Normalizer.Form.NFKD));
}
@Test
void givenStringWithDecomposableUnicodeCharacters_whenRemoveAccents_thenReturnASCIIString() {
assertEquals("aaaeiiiiggnnsssuuy", StringNormalizer.removeAccents("āăąēîïĩíĝġńñšŝśûůŷ"));
}
@Test
void givenStringWithDecomposableUnicodeCharacters_whenRemoveAccentsWithApacheCommons_thenReturnASCIIString() {
assertEquals("aaaeiiiiggnnsssuuy", StringNormalizer.removeAccentsWithApacheCommons("āăąēîïĩíĝġńñšŝśûůŷ"));
}
@Test
void givenStringWithNondecomposableUnicodeCharacters_whenRemoveAccents_thenReturnOriginalString() {
assertEquals("łđħœ", StringNormalizer.removeAccents("łđħœ"));
}
@Test
void givenStringWithNondecomposableUnicodeCharacters_whenRemoveAccentsWithApacheCommons_thenReturnModifiedString() {
assertEquals("lđħœ", StringNormalizer.removeAccentsWithApacheCommons("łđħœ"));
}
@Test
void givenStringWithDecomposableUnicodeCharacters_whenUnicodeValueOfNormalizedString_thenReturnUnicodeValue() {
assertEquals("\\u0066 \\u0069", StringNormalizer.unicodeValueOfNormalizedString("fi"));
assertEquals("\\u0061 \\u0304", StringNormalizer.unicodeValueOfNormalizedString("ā"));
assertEquals("\\u0069 \\u0308", StringNormalizer.unicodeValueOfNormalizedString("ï"));
assertEquals("\\u006e \\u0301", StringNormalizer.unicodeValueOfNormalizedString("ń"));
}
@Test
void givenStringWithNonDecomposableUnicodeCharacters_whenUnicodeValueOfNormalizedString_thenReturnOriginalValue() {
assertEquals("\\u0142", StringNormalizer.unicodeValueOfNormalizedString("ł"));
assertEquals("\\u0127", StringNormalizer.unicodeValueOfNormalizedString("ħ"));
assertEquals("\\u0111", StringNormalizer.unicodeValueOfNormalizedString("đ"));
}
}

42
core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtilsUnitTest.java Normal file
View File

@ -0,0 +1,42 @@
package com.baeldung.doublequotesremoval;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class DoubleQuotesRemovalUtilsUnitTest {
@Test
public void given_EmptyString_ShouldReturn_EmptyString() {
String input = "";
assertTrue(DoubleQuotesRemovalUtils.removeWithSubString(input).isEmpty());
assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input).isEmpty());
assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input).isEmpty());
assertTrue(DoubleQuotesRemovalUtils.removeWithGuava(input).isEmpty());
}
@Test
public void given_DoubleQuotesOnly_ShouldReturn_EmptyString() {
String input = "\"\"";
assertTrue(DoubleQuotesRemovalUtils.removeWithSubString(input).isEmpty());
assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input).isEmpty());
assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input).isEmpty());
assertTrue(DoubleQuotesRemovalUtils.removeWithGuava(input).isEmpty());
}
@Test
public void given_TextWithDoubleQuotes_ShouldReturn_TextOnly() {
String input = "\"Example of text for this test suit\"";
String expectedResult = "Example of text for this test suit";
assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithSubString(input));
assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input));
assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input));
assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithGuava(input));
}
}

2
persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-off.properties
View File

@ -5,7 +5,7 @@ spring.datasource.password=
spring.jpa.hibernate.ddl-auto=create-drop
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.datasource.data=data-trans.sql
spring.sql.init.data-locations=data-trans.sql
logging.level.org.hibernate.SQL=INFO
logging.level.org.hibernate.type=INFO

2
persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-on.properties
View File

@ -5,7 +5,7 @@ spring.datasource.password=
spring.jpa.hibernate.ddl-auto=create-drop
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.datasource.data=data-trans.sql
spring.sql.init.data-locations=data-trans.sql
logging.level.org.hibernate.SQL=INFO
logging.level.org.hibernate.type=INFO

2
persistence-modules/spring-boot-persistence/src/test/resources/application.properties
View File

@ -13,4 +13,4 @@ hibernate.cache.use_query_cache=true
hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory
spring.jpa.properties.hibernate.hbm2ddl.import_files=import_books.sql
spring.datasource.data=import_*_users.sql
spring.sql.init.data-locations=import_*_users.sql

46
persistence-modules/spring-data-cassandra/pom.xml
View File

@ -16,46 +16,15 @@
<dependencies>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-cassandra</artifactId>
<version>${org.springframework.data.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
<exclusions>
<exclusion>
<artifactId>commons-logging</artifactId>
<groupId>commons-logging</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-cassandra</artifactId>
<version>${spring-boot-starter-data-cassandra.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
@ -91,17 +60,10 @@
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.datastax.cassandra</groupId>
<artifactId>cassandra-driver-core</artifactId>
<version>${cassandra-driver-core.version}</version>
<optional>true</optional>
</dependency>
</dependencies>
<properties>
<org.springframework.data.version>1.3.2.RELEASE</org.springframework.data.version>
<cassandra-driver-core.version>2.1.5</cassandra-driver-core.version>
<spring-boot-starter-data-cassandra.version>1.3.2.RELEASE</spring-boot-starter-data-cassandra.version>
<cassandra-unit-spring.version>2.1.9.2</cassandra-unit-spring.version>
<cassandra-unit-shaded.version>2.1.9.2</cassandra-unit-shaded.version>
<hector-core.version>2.0-0</hector-core.version>

2
persistence-modules/spring-data-jpa-annotations/src/main/resources/ddd.properties
View File

@ -1 +1 @@
spring.datasource.initialization-mode=never
spring.sql.init.mode=never

2
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/UserRepositoryIntegrationTest.java
View File

@ -19,7 +19,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
@RunWith(SpringRunner.class)
@DataJpaTest(properties = "spring.datasource.data=classpath:insert_users.sql")
@DataJpaTest(properties = "spring.sql.init.data-locations=classpath:insert_users.sql")
public class UserRepositoryIntegrationTest {
@Autowired

2
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/datetime/ArticleRepositoryIntegrationTest.java
View File

@ -17,7 +17,7 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@RunWith(SpringRunner.class)
@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
@DataJpaTest(properties="spring.sql.init.data-locations=classpath:import_entities.sql")
public class ArticleRepositoryIntegrationTest {
@Autowired

2
persistence-modules/spring-data-jpa-query/src/main/resources/application-joins.properties
View File

@ -1 +1 @@
spring.datasource.data=classpath:db/import_joins.sql
spring.sql.init.data-locations=classpath:db/import_joins.sql

2
persistence-modules/spring-data-jpa-repo/src/test/java/com/baeldung/boot/daos/JpaRepositoriesIntegrationTest.java
View File

@ -21,7 +21,7 @@ import com.baeldung.boot.domain.Location;
import com.baeldung.boot.domain.Store;
@RunWith(SpringRunner.class)
@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
@DataJpaTest(properties="spring.sql.init.data-locations=classpath:import_entities.sql")
public class JpaRepositoriesIntegrationTest {
@Autowired
private LocationRepository locationRepository;

1
persistence-modules/spring-jdbc/README.md
View File

@ -4,3 +4,4 @@
- [Spring JDBC](https://www.baeldung.com/spring-jdbc-jdbctemplate)
- [Spring JdbcTemplate Unit Testing](https://www.baeldung.com/spring-jdbctemplate-testing)
- [Using a List of Values in a JdbcTemplate IN Clause](https://www.baeldung.com/spring-jdbctemplate-in-list)
- [Obtaining Auto-generated Keys in Spring JDBC](https://www.baeldung.com/spring-jdbc-autogenerated-keys)

1
persistence-modules/spring-jpa/README.md
View File

@ -6,7 +6,6 @@
- [Sorting with JPA](https://www.baeldung.com/jpa-sort)
- [Self-Contained Testing Using an In-Memory Database](https://www.baeldung.com/spring-jpa-test-in-memory-database)
- [A Guide to Spring AbstractRoutingDatasource](https://www.baeldung.com/spring-abstract-routing-data-source)
- [Obtaining Auto-generated Keys in Spring JDBC](https://www.baeldung.com/spring-jdbc-autogenerated-keys)
- [Spring Data Annotations](http://www.baeldung.com/spring-data-annotations)
- More articles: [[next -->]](/spring-jpa-2)

38
spring-5/src/main/java/com/baeldung/jdbc/autogenkey/repository/MessageRepositoryJDBCTemplate.java
View File

@ -1,38 +0,0 @@
package com.baeldung.jdbc.autogenkey.repository;
import java.sql.PreparedStatement;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Repository;
@Repository
public class MessageRepositoryJDBCTemplate {
@Autowired
JdbcTemplate jdbcTemplate;
final String INSERT_MESSAGE_SQL = "insert into sys_message (message) values(?) ";
public long insert(final String message) {
KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(connection -> {
PreparedStatement ps = connection.prepareStatement(INSERT_MESSAGE_SQL);
ps.setString(1, message);
return ps;
}, keyHolder);
return (long) keyHolder.getKey();
}
final String SELECT_BY_ID = "select message from sys_message where id = ?";
public String getMessageById(long id) {
return this.jdbcTemplate.queryForObject(SELECT_BY_ID, String.class, new Object[] { id });
}
}

29
spring-5/src/main/java/com/baeldung/jdbc/autogenkey/repository/MessageRepositorySimpleJDBCInsert.java
View File

@ -1,29 +0,0 @@
package com.baeldung.jdbc.autogenkey.repository;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.stereotype.Repository;
@Repository
public class MessageRepositorySimpleJDBCInsert {
SimpleJdbcInsert messageInsert;
@Autowired
public MessageRepositorySimpleJDBCInsert(DataSource dataSource) {
messageInsert = new SimpleJdbcInsert(dataSource).withTableName("sys_message").usingGeneratedKeyColumns("id");
}
public long insert(String message) {
Map<String, Object> parameters = new HashMap<String, Object>(1);
parameters.put("message", message);
Number newId = messageInsert.executeAndReturnKey(parameters);
return (long) newId;
}
}

9
spring-5/src/main/resources/autogenkey-db.properties
View File

@ -1,9 +0,0 @@
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.username=sa
spring.datasource.password=
spring.datasource.driverClassName=org.h2.Driver
spring.jpa.hibernate.ddl-auto=create
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.datasource.initialize=true
spring.datasource.schema=classpath:autogenkey-schema.sql

5
spring-5/src/main/resources/autogenkey-schema.sql
View File

@ -1,5 +0,0 @@
CREATE TABLE IF NOT EXISTS sys_message (
id bigint(20) NOT NULL AUTO_INCREMENT,
message varchar(100) NOT NULL,
PRIMARY KEY (id)
);

55
spring-5/src/test/java/com/baeldung/jdbc/autogenkey/GetAutoGenKeyByJDBCIntTest.java
View File

@ -1,55 +0,0 @@
package com.baeldung.jdbc.autogenkey;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.test.context.junit4.SpringRunner;
import com.baeldung.jdbc.autogenkey.repository.MessageRepositoryJDBCTemplate;
import com.baeldung.jdbc.autogenkey.repository.MessageRepositorySimpleJDBCInsert;
@RunWith(SpringRunner.class)
@Ignore
public class GetAutoGenKeyByJDBCIntTest {
@Configuration
@EnableAutoConfiguration
@PropertySource("classpath:autogenkey-db.properties")
@ComponentScan(basePackages = { "com.baeldung.jdbc.autogenkey.repository" })
public static class SpringConfig {
}
@Autowired
MessageRepositorySimpleJDBCInsert messageRepositorySimpleJDBCInsert;
@Autowired
MessageRepositoryJDBCTemplate messageRepositoryJDBCTemplate;
final String MESSAGE_CONTENT = "Test";
@Test
public void insertJDBC_whenLoadMessageByKey_thenGetTheSameMessage() {
long key = messageRepositoryJDBCTemplate.insert(MESSAGE_CONTENT);
String loadedMessage = messageRepositoryJDBCTemplate.getMessageById(key);
assertEquals(MESSAGE_CONTENT, loadedMessage);
}
@Test
public void insertSimpleInsert_whenLoadMessageKey_thenGetTheSameMessage() {
long key = messageRepositorySimpleJDBCInsert.insert(MESSAGE_CONTENT);
String loadedMessage = messageRepositoryJDBCTemplate.getMessageById(key);
assertEquals(MESSAGE_CONTENT, loadedMessage);
}
}

1
spring-kafka/src/main/java/com/baeldung/kafka/embedded/KafkaProducerConsumerApplication.java
View File

@ -5,7 +5,6 @@ import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableAutoConfiguration
public class KafkaProducerConsumerApplication {
public static void main(String[] args) {

1
spring-kafka/src/main/java/com/baeldung/kafka/ssl/KafkaSslApplication.java
View File

@ -5,7 +5,6 @@ import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableAutoConfiguration
public class KafkaSslApplication {
public static void main(String[] args) {

4
spring-security-modules/spring-security-acl/src/main/resources/com.baeldung.acl.datasource.properties
View File

@ -8,5 +8,5 @@ spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.h2.console.path=/myconsole
spring.h2.console.enabled=true
spring.datasource.initialize=true
spring.datasource.schema=classpath:acl-schema.sql
spring.datasource.data=classpath:acl-data.sql
spring.sql.init.schema-locations=classpath:acl-schema.sql
spring.sql.init.data-locations=classpath:acl-data.sql

5
spring-security-modules/spring-security-web-boot-2/src/main/resources/application-mysql.properties
View File

@ -1,9 +1,8 @@
spring.datasource.platform=mysql
spring.sql.init.platform=mysql
spring.datasource.url=jdbc:mysql://localhost:3306/jdbc_authentication
spring.datasource.username=root
spring.datasource.password=pass
spring.datasource.initialization-mode=always
spring.sql.init.mode=always
spring.jpa.hibernate.ddl-auto=none
spring.profiles.active=mysql

4
spring-security-modules/spring-security-web-boot-2/src/main/resources/application-postgre.properties
View File

@ -1,7 +1,7 @@
spring.datasource.platform=postgre
spring.sql.init.platform=postgre
spring.datasource.url=jdbc:postgresql://localhost:5432/jdbc_authentication
spring.datasource.username=postgres
spring.datasource.password=pass
spring.datasource.initialization-mode=always
spring.sql.init.mode=always
spring.jpa.hibernate.ddl-auto=none

1
spring-security-modules/spring-security-web-mvc-custom/pom.xml
View File

@ -175,6 +175,7 @@
<!-- util -->
<guava.version>19.0</guava.version>
<!-- Maven plugins -->
<maven-war-plugin.version>3.2.2</maven-war-plugin.version>
<cargo-maven2-plugin.version>1.6.1</cargo-maven2-plugin.version>
</properties>

19
spring-security-modules/spring-security-web-mvc-custom/src/main/java/com/baeldung/web/interceptor/LoggerInterceptor.java
View File

@ -1,16 +1,18 @@
package com.baeldung.web.interceptor;
import com.google.common.base.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import java.util.Enumeration;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration;
public class LoggerInterceptor extends HandlerInterceptorAdapter {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import com.google.common.base.Strings;
public class LoggerInterceptor implements HandlerInterceptor {
private static Logger log = LoggerFactory.getLogger(LoggerInterceptor.class);
@ -50,7 +52,8 @@ public class LoggerInterceptor extends HandlerInterceptorAdapter {
if (posted.length() > 1)
posted.append("&");
final String curr = (String) e.nextElement();
posted.append(curr).append("=");
posted.append(curr)
.append("=");
if (curr.contains("password") || curr.contains("answer") || curr.contains("pwd")) {
posted.append("*****");
} else {

7
spring-security-modules/spring-security-web-mvc-custom/src/main/java/com/baeldung/web/interceptor/SessionTimerInterceptor.java
View File

@ -8,10 +8,10 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
public class SessionTimerInterceptor extends HandlerInterceptorAdapter {
public class SessionTimerInterceptor implements HandlerInterceptor {
private static Logger log = LoggerFactory.getLogger(SessionTimerInterceptor.class);
@ -30,7 +30,8 @@ public class SessionTimerInterceptor extends HandlerInterceptorAdapter {
request.setAttribute("executionTime", startTime);
if (UserInterceptor.isUserLogged()) {
session = request.getSession();
log.info("Time since last request in this session: {} ms", System.currentTimeMillis() - request.getSession().getLastAccessedTime());
log.info("Time since last request in this session: {} ms", System.currentTimeMillis() - request.getSession()
.getLastAccessedTime());
if (System.currentTimeMillis() - session.getLastAccessedTime() > MAX_INACTIVE_SESSION_TIME) {
log.warn("Logging out, due to inactive session");
SecurityContextHolder.clearContext();

31
spring-security-modules/spring-security-web-mvc-custom/src/main/java/com/baeldung/web/interceptor/UserInterceptor.java
View File

@ -1,18 +1,18 @@
package com.baeldung.web.interceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.SmartView;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class UserInterceptor extends HandlerInterceptorAdapter {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.SmartView;
import org.springframework.web.servlet.View;
public class UserInterceptor implements HandlerInterceptor {
private static Logger log = LoggerFactory.getLogger(UserInterceptor.class);
@ -44,7 +44,9 @@ public class UserInterceptor extends HandlerInterceptorAdapter {
*/
private void addToModelUserDetails(HttpSession session) {
log.info("================= addToModelUserDetails ============================");
String loggedUsername = SecurityContextHolder.getContext().getAuthentication().getName();
String loggedUsername = SecurityContextHolder.getContext()
.getAuthentication()
.getName();
session.setAttribute("username", loggedUsername);
log.info("user(" + loggedUsername + ") session : " + session);
log.info("================= addToModelUserDetails ============================");
@ -56,7 +58,9 @@ public class UserInterceptor extends HandlerInterceptorAdapter {
*/
private void addToModelUserDetails(ModelAndView model) {
log.info("================= addToModelUserDetails ============================");
String loggedUsername = SecurityContextHolder.getContext().getAuthentication().getName();
String loggedUsername = SecurityContextHolder.getContext()
.getAuthentication()
.getName();
model.addObject("loggedUsername", loggedUsername);
log.trace("session : " + model.getModel());
log.info("================= addToModelUserDetails ============================");
@ -76,7 +80,10 @@ public class UserInterceptor extends HandlerInterceptorAdapter {
public static boolean isUserLogged() {
try {
return !SecurityContextHolder.getContext().getAuthentication().getName().equals("anonymousUser");
return !SecurityContextHolder.getContext()
.getAuthentication()
.getName()
.equals("anonymousUser");
} catch (Exception e) {
return false;
}

4
xstream/pom.xml
View File

@ -30,8 +30,8 @@
</dependencies>
<properties>
<xstream.version>1.4.10</xstream.version>
<jettison.version>1.3.8</jettison.version>
<xstream.version>1.4.18</xstream.version>
<jettison.version>1.4.1</jettison.version>
</properties>
</project>

6
xstream/src/main/java/com/baeldung/initializer/SimpleXstreamInitializer.java
View File

@ -7,7 +7,11 @@ import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;
public class SimpleXstreamInitializer {
public XStream getXstreamInstance() {
return new XStream();
XStream xstream = new XStream();
xstream.allowTypesByWildcard(new String[]{
"com.baeldung.**"
});
return xstream;
}
public XStream getXstreamJettisonMappedInstance() {

1
xstream/src/test/java/com/baeldung/rce/XStreamBasicsUnitTest.java
View File

@ -21,6 +21,7 @@ public final class XStreamBasicsUnitTest {
public void before() {
xstream = new XStream();
xstream.alias("person", Person.class);
xstream.allowTypes(new Class<?>[] { Person.class });
}
@Test