Test container is a third party Java library which offers to test or validate anything that can run in a Docker container. For Example, we can create lightweight database instances of  MySQL, PostgreSQL or Oracle database to test our data access layer code (DAO , Repositories). Similarly we can test our AWS cloud services like server less apps without actually using the cloud. We can do this with the help of LocalStack, a fully functional local AWS cloud stack.

Local Stack

LocalStack is a cloud service emulator. We can able to run AWS applications like Lambda, S3 entirely on your laptop or machine without connecting to a remote cloud provider.

Why It is needed ?

We can able to connect to AWS services like S3 from Java using their SDK’s. But here the problem is, if we wants to validate our code then we are need to connect cloud sandboxes using AWS SAM or anything like that. And While we access the cloud services, It is billable as well. Secondly we can not write unit test or integration test for this sources in a efficient way which would be a another downside of it. So In this article, we are going to learn to write unit testing for AWS S3 services with the help of Local stack and Test containers. Let’s dive into that. Cheers.

Prerequisite

• Java
• Maven
• Docker

Create a Spring initializer project

First, I am creating basic spring initializer project with Spring boot starter, Spring boot test and AWS SDK maven dependencies.

<dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-java-sdk</artifactId>
            <version>1.11.163</version>
</dependency>

Creating AWS S3 Client

Second, now I am creating AWS S3 client with simple upload object functionality. Here I am validating whether the bucket is exist or not, followed by uploading an object into the S3 storage system.

package awsservicestutorial.client;

import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.model.ObjectMetadata;

import java.io.IOException;
import java.io.InputStream;
import java.net.URLConnection;
import java.nio.file.Files;
import java.nio.file.Path;

public class AwsS3Client {

    private final AmazonS3 amazonS3;

    public AwsS3Client(final AmazonS3 amazonS3) {
        this.amazonS3 = amazonS3;
    }

    public void uploadObject(final String bucketName, final Path path) throws IOException {

        isBucketExists(bucketName);

        final String filename = path.getFileName().toString();

        final ObjectMetadata metadata = new ObjectMetadata();
        metadata.setContentType(URLConnection.guessContentTypeFromName(filename));
        metadata.setSSEAlgorithm("AES256");
        metadata.setContentLength(Files.size(path));

        try(final InputStream stream = Files.newInputStream(path)){
            amazonS3.putObject(bucketName, filename, stream, metadata);
        }
    }

    private void isBucketExists(final String bucketName) {
        if(!amazonS3.doesBucketExist(bucketName)) {
            throw new IllegalStateException(String.format("Bucket %s does not exist", bucketName));
        }
    }

}

Local Stack and Test Container Dependencies

Add the following dependency to your pom.xml for using local stack and test container libraries.

        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>localstack</artifactId>
            <version>1.17.6</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>1.17.6</version>
            <scope>test</scope>
        </dependency>

Here I am using Junit-5 for unit testing the application. It is up to to decide whether Junit 5 or 4. We can do this with Junit 4 as well.

AWS S3 Client – Local Stack – Test Container – Create Unit Test

Creating unit test with local stack is really very simple. we just need to create local stack instance. This instance can act as AWS S3 services with the help of test container and docker. It will create a exact AWS mock in local or in our CI environment. This will reduce a lot money, since we don’t need to interact AWS cloud services during local development and testing.

package awsservicestutorial;

import awsservicestutorial.client.AwsS3Client;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.testcontainers.containers.localstack.LocalStackContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Optional;

@Testcontainers(disabledWithoutDocker = true)
@ExtendWith(SpringExtension.class)
class AwsServicesTutorialApplicationTests {
    private static final String BUCKET_NAME = "test-bucket";
    @Container
    public final static LocalStackContainer LOCAL_STACK_CONTAINER =
            new LocalStackContainer(DockerImageName.parse("localstack/localstack:0.12.16"))
                    .withServices(LocalStackContainer.Service.S3).withEnv("DEFAULT_REGION", "us-east-1");
    private AmazonS3 amazonS3 = AmazonS3ClientBuilder.standard()
            .withEndpointConfiguration(LOCAL_STACK_CONTAINER.getEndpointConfiguration(LocalStackContainer.Service.S3))
            .withCredentials(LOCAL_STACK_CONTAINER.getDefaultCredentialsProvider()).build();

    private AwsS3Client awsS3Client;

    @BeforeEach
    public void beforeEach() throws IOException, InterruptedException {
        LOCAL_STACK_CONTAINER.execInContainer("awslocal", "s3", "mb", "s3://" + BUCKET_NAME);
        awsS3Client = new AwsS3Client(amazonS3);
    }

    @AfterEach
    public void afterEach() throws IOException, InterruptedException {
        LOCAL_STACK_CONTAINER.execInContainer("awslocal", "s3", "rb", "s3://" + BUCKET_NAME, "--force");
    }

    /**
     * First assert whether localstack is running!
     */
    @Test
    public void test_isLocalstackRunning() {
        Assertions.assertTrue(LOCAL_STACK_CONTAINER.isRunning());
    }

    @Test
    public void test_uploadObjectSuccess() throws URISyntaxException, IOException {

        awsS3Client.uploadObject(BUCKET_NAME, createPath());
        Assertions.assertTrue(amazonS3.doesObjectExist(BUCKET_NAME, "sample.csv"));
    }

    @Test
    public void tes_uploadObjectError() throws IOException, InterruptedException {

        LOCAL_STACK_CONTAINER.execInContainer("awslocal", "s3", "rb", "s3://" + BUCKET_NAME, "--force");
        Assertions.assertThrows(IllegalStateException.class, () -> awsS3Client.uploadObject(BUCKET_NAME, createPath()));
    }

    private Path createPath() throws URISyntaxException {
        return Optional.ofNullable(ClassLoader.getSystemResource("sample.csv").toURI())
                .map(Paths::get)
                .orElseThrow(IllegalArgumentException::new);
    }

}

• First, I am validating whether the local or CI machine having docker environment.
• Second, @Container creates the local stack container instance and mimic the AWS S3 as we are providing S3 as a service here. If you are using Junit-4, then you must use @ClassRule annotation here.
• During beforeEach() method, we are just creating the bucket in the S3 where as afterEach() method deletes the bucket after each test execution.
• You will need to create sample.csv file under test/resources directory for uploading into local stack S3.
• During upload test, once the file upload has been done, we can assert that using amazonS3.doesObjectExist method, whether the file has been successfully uploaded or not.
• And also we are validating after deleting the the bucket, whether it is throwing IllegalStateException exception or not.
• Finally In this way, we tested our AWS S3 client class effectively without connecting into AWS services.

AWS S3 Client – Local Stack – Test Container – Code Sample

• https://github.com/programeasily/aws-services-tutorial/blob/main/src/main/java/awsservicestutorial/client/AwsS3Client.java
• https://github.com/programeasily/aws-services-tutorial/blob/main/src/test/java/awsservicestutorial/AwsServicesTutorialApplicationTests.java
• https://github.com/programeasily/aws-services-tutorial

The post AWS S3 Client – Local Stack – Test Container appeared first on Program Easily.

             1. By Literal in Java

             2. By New Keyword

String Literal in Java

String Literals are very special in Java. We can create String object using double quotes as followed,

String message = "Hello ! I am a string";

The above code calls the intern() method of string first. Then the intern checks whether the same object is exists in pool or not!. If it is exist, it will return the same object reference. Otherwise It will create the new object in the pool and return the new object reference. Ultimately the string literal should be fast if we compare with new keyword since it will not create the new objects every time.

By New Keyword

We can create String object using new keyword as followed,

String message = new String("Hello ! I am a string");

The above code creates two string objects. It will create one object in Heap Memory directly and other in String Pool Area. And the reference will points to heap memory object.

Caution in String Compare

We have to use equals method of string to compare two strings always, not ==. Because == compares only the memory locations. But the equals method compare the memory location as well as the content of the stored objects.

String a = "Hello";
String b = "Hello";

// since literals re-use existing objects from the pool
System.out.println(a == b) // true

String c = new String("Hello");

// new keyword always creates new objects in the heap
// And == compares the memory locations not the exact
// content of the objects
System.out.println(a == c) // false

// Always use equals for comparison
// String class equals method checks the content of the 
// object as well
System.out.println(a.equals(c)) // true

Why String is Immutable

The rule to create any immutable object is, it’s state can not be changed after it is created. And String class designed to follow this rule. Even we could create N number of objects by following this rule. Let’s come to the point, why string is immutable ? The most correct answer is probably: Because the java language authors or designers figured it was a good idea. So that It will provide lot of benefits to us, Let’s see one by one.

Security

We have been mostly using string object in network connections, database connection URLs, usernames/passwords and etc. It it were mutable, we can change these parameters and runtime And which creates security issues.

Synchronization And Concurrency

We can say an object is thread safe, when multiple threads are operating on it but none of them is able to corrupt its state and object hold the same state for every thread at any point in time. Making String immutable automatically makes them thread safe by default thereby solving the synchronization issues.

Caching

when compiler optimizes your String objects, it sees that if two objects have same value (a=”test”, and b=”test”) and thus you need only one string object (for both a and b, these two will point to the same object)

Hash Code Caching

String object caches its hash code at the time of object creation which makes it the great candidate for hashing related operations because hash code doesn’t need to be calculated again which save us some time. This is why String is mostly used as Hash Map keys

Class Loading

We have been using String as an arguments for class loading. If mutable, it could result in wrong class being loaded (because mutable objects change their state).

Summary

1. Usually we design classes as immutable for them being thread safe and to optimize performance and memory consumption.

2. Security and Efficiency to be the primary design goals, then immutable strings are a means to meet those goals.

3. immutable objects in java are like copy-by-value, you can have 2 references to a String, but you should consider them 2 separate Strings since it’s immutable, and working with one of them won’t affect the other.

You May Also Like

• Java 8 Interview Questions for Experienced

The post String in Java – String Literal, String Pool, String Objects appeared first on Program Easily.

Java edition 8 is a major release after the 6th edition. In this article we are going to refresh the concepts which will help us to improve the interview experience. Let’s take a deep dive into it.

Java 8 Interview Questions for Experienced

1. Features of Java 8

• Lambda Expressions – Lambda expressions are anonymous functions or methods without the name
• Functional Interface – It is a single abstract method (SAM) interface, i.e. interface with only one abstract method.
• Default Method – the default implementation of the method and we can override it in the concrete class if required.
• Method Reference – It will just refer to the existing method with name. An easy way of referring to a method of a functional interface.
• Stream – a sequence of elements involved with sequential and parallel aggregate operations. The operations are composed into a stream pipeline.
• Optional – A wrapper object which may or may not contain a non null value.
• Static methods in interface – Static methods makes it easier to organize the helper methods in our libraries. We can create static methods specific to an interface in the same interface rather than in a separate class.
• Nashorn – The Nashorn engine is an implementation of the ECMAScript. Nashorn Java API allows us to write Java Applications as scripts which can be interpreted by the Nashorn engine.

2. What are functional interface

Java 8 introduced the concept of functional programming with the help of functional interfaces. It is a single abstract method (SAM) interface, i.e. interface with only one abstract method. So one abstract method is responsible for one particular functionality. @FunctionalInterface annotation is used to indicate that the interface is a functional interface. This annotation is not mandatory. It just let the compilers to throw the error incase if we maintain more than one abstract method in the interface.

Note that, we can create the functional interface instances with the help of lambda expressions, method references or constructor references.

3. Some Predefined functional interfaces

• Consumer – a function that accepts a single input argument and returns no result.
• Function – a function that accepts one argument and produces a result.
• Predicate – Represents a predicate (boolean-valued function) of one argument.
• Supplier – a function that does not accept input and produces a result.

4. What is lambda expression

Lambda expressions are anonymous functions or methods without the name. We can replace the anonymous class implementation with the help of lambda expressions after Java-8. We can pass functionality as an argument to another method here. Some of the key points are,

• Function without a name
• Anonymous function
• Executes on demand
• Applied only to functional interface
• Standalone, does not belong to any class

The Lambda expression syntax consists of the following,

1. A comma separated list of parameters enclosed in parentheses
2. The Arrow token, ->
3. A Body, which consists of a single expression or a statement block.

// single parameter and single expression example,
p -> p.getGender() > 25 && p.getGender() <= 18

// multiple parameter example,
( a, b ) -> a + b;

// statement block example,
p ->{
     return  p.getGender() > 25 && p.getGender() <= 18 ;
}

5. What is default method

Before Java 8, interfaces allowed abstract methods only. From Java-8, we can do the abstract method implementation in the interface itself. Let’s say the default implementation of the method and we can override it in the concrete class if required.

The idea behind the default method is that the java-8 team wants to introduce new abstract methods in the old utility libraries. If they do so, it will provide compiler error to all it’s implemented classes. So the default method was introduced to ensure backward compatibility. It enables you to add new methods to the old interfaces with the compatibility of it’s older versions of those interfaces.

6. What is Method Reference

Sometimes we want to create the lambda function(anonymous function) that does nothing but call an existing method. Here we are having the super shortcut called method reference. It will just refer to the existing method by name, an easy way of referring to a method of a functional interface.

// a lambda expression does nothing but call an existing method
Arrays.sort(rosterAsArray,
    (a, b) -> Person.compareByAge(a, b)
);

// Using method reference
// refer to the existing method by name
Arrays.sort(rosterAsArray, Person::compareByAge);

7. What is Optional

A wrapper object which may or may not contain a non null value. We can use optional to handle null values after Java-8. If value is not null, isPresent() will return true and get() will return the value.

// Creates the optional object
Optional.of(argument);

8. What is Stream

A Stream is not a data structure that stores elements. It does not hold any data(No Storage). Whereas, is a sequence of elements involved with sequential and parallel aggregate operations. The operations are composed into a stream pipeline. The Stream pipeline consist of below components,

• A source (array, collection, generator function, an I/O channel)
• Zero or more intermediate operations (each intermediate operation transform a stream into another stream)
• A terminal operation (produces a result or side-effect)

Here the important information is, you can have a number of intermediate operations and computation on the source data which is performed only when the terminal operation is initiated. Streams are Lazy and source elements are consumed only as needed.

9. Stream vs Collection

10. Intermediate operation vs Terminate operations in Stream

Stream operations are divided into intermediate operations and terminal operations. They are combined to form a stream pipeline. Intermediate operations return a new stream. It’s always lazy, meaning that executing intermediate operations such as filter() does not actually perform. But creates a new stream. When terminal operation is initiated, the traversal of all intermediate operations will be executed. Terminal operations such as Stream.forEach may traverse the stream to produce the final result. After the terminal operation is performed, the stream pipeline is considered as consumed and can no longer be used.

11. map vs flatmap

map – Transforms the stream by applying the given function to all the elements of its stream. It is an intermediate operation.

// transforms all elements to uppercase
Stream.of("apple", "meta", "google")
        .map(mapper -> mapper.toUpperCase()).collect(Collectors.toList());
// output
[APPLE, META, GOOGLE]

flatMap – flattening the resulting elements into a new stream. One-to-many transformation to the elements of the stream.

List<Integer> list1 = Arrays.asList(1,2,3);
        List<Integer> list2 = Arrays.asList(4,5,6);
        List<Integer> list3 = Arrays.asList(7,8,9);
        // flatten the elements into a single list
        List<Integer> result = Stream.of(list1, list2, list3)
        .flatMap(list -> list.stream()).collect(Collectors.toList());

// output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

12. findFirst vs findAny vs anyMatch vs allMatch vs noneMatch

findFirst – To find the first element of the stream. It will return the Optional object with either the first element or the empty optional object. This is a terminal operation.

Optional<String> first = Stream.of("apple", "meta", "google").findFirst();
System.out.println(first.get());
// output
apple

findAny – To find any element of the stream. It will return the Optional object with any one of the elements or the empty optional object. This is also a terminal operation.

Optional<String> any = Stream.of("apple", "meta", "google").findAny();
System.out.println(any.get());
// output
apple

anyMatch – Returns true if any one of the elements evaluates true with the provided predicate. If the stream is empty or all elements evaluate false with the provided predicate then it will return false.

boolean any = Stream.of("apple", "meta", "google").anyMatch(predicate -> predicate.equals("apple"));
System.out.println(any);
// output
true

allMatch – Returns true if all the elements evaluate true with the provided predicate. If the stream is empty then it will return true without evaluating the predicate.

boolean allMatch = Stream.of("apple", "meta", "google").allMatch(predicate -> predicate instanceof String);
System.out.println(allMatch);
// output
true

noneMatch – Returns true if no elements evaluate true with the provided predicate. If the stream is empty then it will return true without evaluating the predicate.

boolean noneMatch = Stream.of("apple", "meta", "google").noneMatch(predicate -> predicate.equals("facebook"));
System.out.println(noneMatch);
// output
true

13. skip vs limit vs count

skip – discards the first N elements of the stream. If the stream contains less elements than N ,then it will return an empty stream. This is an intermediate operation.

List<Integer> skipList = Stream.of(10,20,30,40,50).skip(2).collect(Collectors.toList());
System.out.println(skipList);
// output
[30, 40, 50]

limit – returns only the first N elements of the stream. It will throw an exception if the N is negative. This is also an intermediate operation.

// first skip the list, and then limit from it
List<Integer> limitList = Stream.of(10,20,30,40,50).skip(2).limit(2).collect(Collectors.toList());
System.out.println(limitList);
// output
[30, 40]

count – returns the count of elements in the stream. This is a terminal operation.

Long count = Stream.of(10,20,30,40,50).skip(2).limit(2).count();
System.out.println(count);
// output
2

14. map vs filter vs forEach vs sorted

map – a transformation operation. Returns a new stream after applying the given Function to all the elements of this stream. This is an intermediate operation.

<R> Stream<R> map(Function<? super T, ? extends R> mapper);
// Transformation operation
List<String> strings =  Stream.of("apple", "meta", "google")
        .map(mapper -> mapper.toUpperCase()).collect(Collectors.toList());
// output
[APPLE, META, GOOGLE]

filter – Returns a new stream which matches the given predicate(the predicate should evaluate true). This is also an intermediate operation.

Stream<T> filter(Predicate<? super T> predicate);
// Filter operation
List<Integer> filterList = Stream.of(10,20,30,40,50)
                .filter(predicate -> predicate > 25).collect(Collectors.toList());
// output
[30, 40, 50]

forEach – Performs the action for each element of this stream. This is a terminal operation.

void forEach(Consumer<? super T> action);
// Just performs an action of its element
Stream.of(10,20,30,40,50).forEach(action -> System.out.println(action));
// output
10
20
30
40
50

sorted – Returns a new stream after sorting the elements based on the provided Comparator. This is an intermediate operation.

// Default sorting is ascending without Comparator
List<Integer> sortedList1 = Stream.of(4,2,3,1).sorted().collect(Collectors.toList());

// Based on provided Comparator 
List<Integer> sortedList2 = Stream.of(4,2,3,1).sorted(Comparator.reverseOrder()).collect(Collectors.toList());

// output - sortedList1
[1, 2, 3, 4]
// output - sortedList12
[4, 3, 2, 1]

15. groupBy vs mapping

groupBy – groups the elements based on the classification function and returns the result in the map. The key should be the grouping element and value should be the list.

The following will classify Person objects by city:

Map<String, List<Person>> peopleByCity = personStream.collect(Collectors.groupingBy(Person::getCity);
 
The following will classify Person objects by state and city, cascading two Collectors together:

     Map<String, Map<String, List<Person>>> peopleByStateAndCity =personStream.collect(Collectors.groupingBy(Person::getState,
                                        Collectors.groupingBy(Person::getCity)));

mapping – When we do collect with reduction operation, we can transform the element by applying the mapping function to each input before accumulation. In the below example, the Person object transforms to last name during the accumulation.

Map<City, Set<String>> lastNamesByCity
            = people.stream().collect(
              groupingBy(Person::getCity,
                         mapping(Person::getLastName,
                                toSet())));

16. Reduction operations

A reduction operation takes a sequence of input elements and combines them into a single summary result. For example, finding the sum or accumulating elements into a list. The stream classes have multiple forms of general reduction operations called reduce() and collect(). And we are having reductions forms such as sum(), max(), or count().

int sum = 0;
for (int x : numbers) {
      sum += x;
}

// Above operation can be implemented using reduction
int sum = numbers.stream().reduce(0, (x,y) -> x+y);

Mutable reduction accumulates input elements into a mutable result container such as a Collection or StringBuilder, as it processes the elements in the stream.

17. stream vs parallel stream which one should use

Parallel stream has a higher view compared to sequential stream. But Parallel stream needs threads which takes a significant amount of time. I would prefer to use sequential streams by default and we can go for parallel ones if

• having large amount of items to process
• having the performance problem
• we don’t already run other process in a multithreaded environment

Meanwhile, note that parallel streams will not solve synchronization problems if predicates and functions in the process uses a shared resource. Here, we have to ensure that all are thread-safe. So whenever we use parallel streams, we should worry about side effects.

18. why static method introduced in Interface with Java 8

Static methods make it easier to organize the helper methods in our libraries. We can create static methods specific to an interface in the same interface rather than in a separate class. We can also ignore public modifiers since all methods are implicitly public in the interface. At the same time you should be careful that the interface has to be clear and does not create additional clutter in the API.

Even the JDK code has Collectors – static factory methods, and a Collector interface at the same time. Those methods could be merged into the Collector interface, but that would make the interface more clunky.

19. Date API’s in Java 8

LocalDate – a date in ISO format(yyyy-MM-dd). LocalDate provides a lot of utility methods to perform various data operations.

LocalDate localDate = LocalDate.now();

LocalDate.of(2015, 02, 20);

LocalDate.parse("2015-02-20");

LocalTime – a time without the date. LocalTime also provides lot of utility methods.

LocalTime now = LocalTime.now();
LocalTime sixThirty = LocalTime.of(6, 30);
LocalTime sixThirty = LocalTime.parse("06:30");

LocalDateTime – a combination of date and time. We can use this while we need the combination of date and time.

LocalDateTime.now();
LocalDateTime.of(2015, Month.FEBRUARY, 20, 06, 30);
LocalDateTime.parse("2015-02-20T06:30:00");

ZonedDateTime API – If we need a zone specific date and time we can go for a ZonedDatTime class. Here the ZoneId used to represent different zones.

ZoneId zoneId = ZoneId.of("Europe/Paris");
ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);
ZonedDateTime.parse("2015-05-03T10:15:30+01:00[Europe/Paris]");

Period and Duration – The Period provides a quantity of time in terms of year, month and days. The Duration provides the quantity of time in terms of seconds and nanosconds.

20. Nashorn Engine in java 8

The Nashorn engine is an implementation of ECMAScript. It was developed in the Java language as the Nashorn project. The Nashorn engine is included in the JDK in Java 1.8. Nashorn Java API allows us to write Java Applications as scripts which can be interpreted by the Nashorn engine.

You May Also Like

• Basic Git Commands – Part 1
• React Best Free Admin Dashboard Template in 2021

The post Java 8 Interview Questions for Experienced appeared first on Program Easily.