What are AWS core services

 Amazon Web Services (AWS) is a cloud computing platform that provides a wide range of services to help individuals and businesses manage their computing resources. Some of the core AWS services include:

Amazon EC2 (Elastic Compute Cloud): This service provides scalable compute capacity in the cloud, allowing users to launch virtual machines and run applications in a highly available and secure environment.

Amazon S3 (Simple Storage Service): This service provides scalable and durable object storage for any kind of data, allowing users to store and retrieve data from anywhere on the internet.

Amazon RDS (Relational Database Service): This service provides managed relational databases, allowing users to easily set up, operate, and scale a relational database in the cloud.

Amazon VPC (Virtual Private Cloud): This service allows users to create a private network within the AWS cloud, providing isolation and security for their resources.

Amazon CloudFront: This service provides a content delivery network (CDN) that enables users to distribute content globally with low latency and high data transfer speeds.

Amazon Route 53: This service provides a highly available and scalable domain name system (DNS) that enables users to route traffic to their web applications.

AWS Lambda: This service allows users to run code in response to events, without the need to provision or manage servers.

Amazon DynamoDB: This service provides a fully managed NoSQL database that supports both document and key-value data models.

AWS IAM (Identity and Access Management): This service provides granular control over access to AWS resources, allowing users to manage user and group permissions.

AWS CloudFormation: This service provides a way to create and manage AWS resources through code, allowing users to provision and configure infrastructure in a repeatable and automated way.

Java Versions - 8 and more

- Java 8 -

Java 8 was a massive release and you can find a list of all features at the Oracle website. There’s two main feature sets I’d like to mention here, though:

Language Features: Lambdas etc.

Before Java 8, whenever you wanted to instantiate, for example, a new Runnable, you had to write an anonymous inner class like so:

 Runnable runnable = new Runnable(){
       @Override
       public void run(){
         System.out.println("Hello world !");
       }
     };

With lambdas, the same code looks like this:

Runnable runnable = () -> System.out.println("Hello world two!");

You also got method references, repeating annotations, default methods for interfaces and a few other language features.

Collections & Streams

In Java 8 you also got functional-style operations for collections, also known as the Stream API. A quick example:

List<String> list = Arrays.asList("franz", "ferdinand", "fiel", "vom", "pferd");

Now pre-Java 8 you basically had to write for-loops to do something with that list.

With the Streams API, you can do the following:

list.stream()
    .filter(name -> name.startsWith("f"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);

- Java 9 -

Java 9 also was a fairly big release, with a couple of additions:

Collections

Collections got a couple of new helper methods, to easily construct Lists, Sets and Maps.

List<String> list = List.of("one", "two", "three");
Set<String> set = Set.of("one", "two", "three");
Map<String, String> map = Map.of("foo", "one", "bar", "two");

Streams

Streams got a couple of additions, in the form of takeWhile,dropWhile,iterate methods.

Stream<String> stream = Stream.iterate("", s -> s + "s")
  .takeWhile(s -> s.length() < 10);

Optionals

Optionals got the sorely missed ifPresentOrElse method.

user.ifPresentOrElse(this::displayAccount, this::displayLogin);

Interfaces

Interfaces got private methods:

public interface MyInterface {

    private static void myPrivateMethod(){
        System.out.println("Yay, I am private!");
    }
}

Other Language Features

And a couple of other improvements, like an improved try-with-resources statement or diamond operator extensions.

JShell

Finally, Java got a shell where you can try out simple commands and get immediate results.

% jshell
|  Welcome to JShell -- Version 9
|  For an introduction type: /help intro

jshell> int x = 10
x ==> 10

HTTPClient

Java 9 brought the initial preview version of a new HttpClient. Up until then, Java’s built-in Http support was rather low-level, and you had to fall back on using third-party libraries like Apache HttpClient or OkHttp (which are great libraries, btw!).

With Java 9, Java got its own, modern client - although in preview mode, which means subject to change in later Java versions.

Project Jigsaw: Java Modules and Multi-Release Jar Files

Java 9 got the Jigsaw Module System, which somewhat resembles the good old OSGI specification. It is not in the scope of this guide to go into full detail on Jigsaw, but have a look at the previous links to learn more.

Multi-Release .jar files made it possible to have one .jar file which contains different classes for different JVM versions. So your program can behave differently/have different classes used when run on Java 8 vs. Java 10, for example.

If you want more Java 9 practice

Again, this is just a quick overview of Java 9 features and if you want more thorough explanations and exercises, have a look at the Java 9 core features course.

- Java 10 -

There have been a few changes to Java 10, like Garbage Collection etc. But the only real change you as a developer will likely see is the introduction of the "var"-keyword, also called local-variable type inference.

Local-Variable Type Inference: var-keyword

// Pre-Java 10

String myName = "Marco";

// With Java 10

var myName = "Marco"

Feels Javascript-y, doesn’t it? It is still strongly typed, though, and only applies to variables inside methods (thanks, dpash, for pointing that out again).

- Java 11 -

Java 11 was also a somewhat smaller release, from a developer perspective.

Strings & Files

Strings and Files got a couple new methods (not all listed here):

"Marco".isBlank();
"Mar\nco".lines();
"Marco  ".strip();

Path path = Files.writeString(Files.createTempFile("helloworld", ".txt"), "Hi, my name is!");
String s = Files.readString(path);

Run Source Files

Starting with Java 10, you can run Java source files without having to compile them first. A step towards scripting.

ubuntu@DESKTOP-168M0IF:~$ java MyScript.java

Local-Variable Type Inference (var) for lambda parameters

The header says it all:

(var firstName, var lastName) -> firstName + lastName

HttpClient

The HttpClient from Java 9 in its final, non-preview version.

Other stuff

Flight Recorder, No-Op Garbage Collector, Nashorn-Javascript-Engine deprecated etc.

- Java 12 -

Java 12 got a couple new features and clean-ups, but the only ones worth mentioning here are Unicode 11 support and a preview of the new switch expression, which you will see covered in the next section.

- Java 13 -

You can find a complete feature list here, but essentially you are getting Unicode 12.1 support, as well as two new or improved preview features (subject to change in the future):

FAQ on Spring

FAQ on Spring.

1) What does InitializingBean and DisposableBean important in Spring bean life cycle?
Answer : The InitializingBean is marker interface and If we mark our bean implements InitializingBean interface then Spring Container will call afterPropertySet() method after initializing the bean instance.
 Same is with DisposableBean marker interface, Spring Container will call destroy() method after releasing the bean instance.

2) What is bean Intercept points in Spring?