JAVA OOPs

Object  Any entity which has state and behavior is known as an object. An object is defined as an
instance of a class.

Class  Collection of objects is called class. It is a logical entity. A class can be defined as a blueprint
from which we can create a new object.

Interface  An interface is a reference type in Java. It is similar to class. It is a collection of abstract

methods. A class implements an interface, thereby inheriting the abstract methods of the interface.
Along with abstract methods, an interface may also contain constants, default methods, static
methods, and nested types.

Inheritance  When one object acquires all the properties and behaviors of a parent object, it is
known as inheritance. Code reusability. It is used to achieve runtime polymorphism.

Polymorphism  If one task is performed in different ways. We use method overloading and
method overriding. One Interface, many implementations
Method overloading  multiple methods having the same name but with different parameters –
Compile time Polymorphism
Method overriding  declaring a method in child class which is already present in parent class –
Runtime Polymorphism

Abstraction  Hiding internal details and showing functionality is known as abstraction. We use
abstract class and interface to achieve abstraction

Encapsulation  Binding code and data together into a single unit.

The List, Set and Map interfaces are very important members of the Java Collections Framework. In
this post, we will point out major differences between them

1. Ordering

List represents an ordered sequence in Java whose elements are accessible by index.

Set represents a distinct collection of elements in Java which can be either ordered or unordered,
depending on the implementation. For example, HashSet implementation is unordered,
LinkedHashSet implementation is ordered, and TreeSet implementation is ordered by natural order
or by provided comparator.

Map represents mapping of key to values in Java. The ordering in Map is also implementation
specific. For example, TreeMap class is ordered while HashMap class is not.

2. Duplicates

Another notable difference between List, Set and Map interface is that a List can have duplicate
elements, a Set contains only distinct elements, and a Map doesn’t permit duplicate keys i.e. each
key can map to at most one value.

3. Null values
List allows any number of null values while a Set contains at most one null element. A Map typically
allows null as a key and value but some implementations prohibit null keys and values.

4. Implementing classes

Few of the most popular implementing classes of the List interface are ArrayList and LinkedList while
that of Set interface includes HashSet, TreeSet and LinkedHashSet. Map interface offers HashMap,
TreeMap, and LinkedHashMap classes.

5. When to use List, Set and Map?

A List can be used when insertion order of elements needs to maintained. A Set can be used if we
need to maintain a collection that contains no duplicates. And Map when data is key-value pairs and
need fast retrieval of value based on some key.
REST based architecture.
GET − Provides a read only access to a resource.
POST − Used to create a new resource.
DELETE − Used to remove a resource.
PUT − Used to update a existing resource or create a new resource.

What is Spring?  Spring framework as “an application framework and inversion of control
container for the Java platform. This can be used for developing enterprise applications in java.

Name the different modules of the Spring framework. 

Spring Context – for dependency injection.
Spring AOP – for aspect-oriented programming.
Spring DAO – for database operations using DAO pattern
Spring JDBC – for JDBC and Data Source support.
Spring ORM – for ORM tools support such as Hibernate
Spring Web Module – for creating web applications.
Spring MVC – Model-View-Controller implementation for creating web applications, web services
etc.

Bean in Spring  Beans are objects that form the backbone of a Spring application. They are
managed by the Spring IoC container. In other words, a bean is an object that is instantiated,
assembled, and managed by a Spring IoC container.

There are five Scopes defined in Spring beans:

Singleton: Only one instance of the bean will be created for each container. This is the default scope
for the spring beans. While using this scope, make sure spring bean doesn’t have shared instance
variables otherwise it might lead to data inconsistency issues because it’s not thread-safe.
Prototype: A new instance will be created every time the bean is requested.
Request: This is same as prototype scope, however it’s meant to be used for web applications. A
new instance of the bean will be created for each HTTP request.
Session: A new bean will be created for each HTTP session by the container.
Global-session: This is used to create global session beans for Portlet applications.

DispatcherServlet is basically the front controller in the Spring MVC application as it loads the spring
bean configuration file and initializes all the beans that have been configured.

ContextLoaderListener, on the other hand, is the listener to start up and shut down the
WebApplicationContext in Spring root.

What is autowiring in Spring?  Autowiring enables the programmer to inject the bean
automatically. We don’t need to write explicit injection logic. The code to inject bean using
dependency injection.

How to handle exceptions in Spring MVC Framework? 

Controller Based: We can define exception handler methods in our controller classes. All we need is
to annotate these methods with @ExceptionHandler annotation.
Global Exception Handler: Exception Handling is a cross-cutting concern and Spring provides
@ControllerAdvice annotation that we can use with any class to define our global exception handler.
HandlerExceptionResolver implementation: For generic exceptions, most of the times we serve
static pages. Spring Framework provides HandlerExceptionResolver interface that we can implement
to create global exception handler. The reason behind this additional way to define global exception
handler is that Spring framework also provides default implementation classes that we can define in
our spring bean configuration file to get spring framework exception handling benefits.

What are some of the important Spring annotations which you have used? 

@Controller – for controller classes in Spring MVC project.

@RequestMapping – for configuring URI mapping in controller handler methods. This is a very
important annotation, so you should go through Spring MVC RequestMapping Annotation Examples

@ResponseBody – for sending Object as response, usually for sending XML or JSON data as
response.

@PathVariable – for mapping dynamic values from the URI to handler method arguments.

@Autowired – for autowiring dependencies in spring beans.

@Qualifier – with @Autowired annotation to avoid confusion when multiple instances of bean type
is present.

@Service – for service classes.

@Scope – for configuring the scope of the spring bean.

@Configuration, @ComponentScan and @Bean – for java-based configurations.

AspectJ annotations for configuring aspects and advices, @Aspect, @Before, @After, @Around,
@Pointcut, etc.

Name the types of transaction management that Spring supports. 

Programmatic transaction management: In this, the transaction is managed with the help of
programming. It provides you extreme flexibility, but it is very difficult to maintain.

Declarative transaction management: In this, transaction management is separated from the

business code. Only annotations or XML based configurations are used to manage the transactions.

What is hibernate?  Hibernate is Java-based ORM tool that provides a framework for mapping
application domain objects to the relational database tables and vice versa.

What are “class access modifiers”?  restrict the scope of a class. Four types – default, public,
private, protected
 Give me any three differences between “Truncate” and “Delete”.

Key Delete Truncate

Basic  It is used to delete specific data  It is used to delete the entire data of the table 

    Where clause  We can use with where clause  It can’t be used with where clause 

Locking  It locks the table row before deleting the row  It locks the entire table 

Rollback  We can rollback the changes. We can’t rollback the changes 

Performance It is slower than truncate  It is faster than delete 

What do you understand by “access specifiers”?  we use this in specifying the visibility of class,
fields, methods or how to give access

What is an abstract class and when do you use it?  Abstract class: is a restricted class that cannot
be used to create objects (to access it, it must be inherited from another class). Java Abstract class is
used to provide common method implementation to all the subclasses or to provide default
implementation.

Abstract method: can only be used in an abstract class, and it does not have a body. The
body is provided by the subclass (inherited from).

What is the difference between UNIQUE and DISTINCT keywords in DBMS?  Unique ensures that
all values in columns are different, Distinct helps to remove all duplicate records while retrieving the
records from table

How would you use Bubble Sort to sort the number of elements? 

for(int i=0; i < n; i++){

for(int j=1; j < (n-i); j++){
if(arr[j-1] > arr[j]){
temp = arr[j-1];
arr[j-1] = arr[j];
arr[j] = temp;
}
}

Exception handling

Try/Catch/Finally:

An exception is an event that arises during the execution. the application

terminates abnormally if the exception is not handled properly. We have
two kinds of exceptions.

 checked exception which we get during compilation

o file not found exception or class not found exception
 unchecked exception which we get during execution
o Array index out of bounds exception

Throwable class is the root class which is extended by Exception & Error.
Throwable has a copy of execution stack.
The throwable has a list of methods which we can use while handling exception.

 A try block can be followed by multiple catch blocks.

 Can have any number of catch blocks after a single try.
 can handle more than one exception using a single catch block.
 The throw keyword is mainly used to throw custom exceptions.
 We can also throw checked or unchecked exceptions.
Exception Propagation:
Exception propagation: An exception is first thrown from the top of the
stack and if it is not caught, it drops down the call stack to the previous method.

Exception Propagation in Unchecked Exceptions:

from the top to the bottom of the stack.

Exception Propagation in Checked Exceptions:

mandatory to use throw keyword here. Checked exceptions throw
compilation error.

- Concurrency (Threads, Runnable, Executors, Callable, Future)

 Threads do multiple things at the same time.

 Life Cycle of a Thread

 New − A new thread begins its life cycle in the new state.
 Runnable − After a newly born thread is started, the thread becomes
runnable.
 Waiting − Sometimes, when the thread waits for another thread to
perform a task, it enters waiting state.
 Timed Waiting – A thread can enter the timed waiting state for a
specified time.
 (Dead) − A runnable thread enters the terminated state when it completes
its task.

Thread Priorities

 Thread priority helps the operating system determine the order of

scheduling.
 The priority is in between MIN_PRIORITY (a constant of 1) and
MAX_PRIORITY (a constant of 10).
 NORM_PRIORITY 5 is default.
 Thread priorities cannot guarantee the order in which threads execute
because they are platform dependent.

Creating a Thread

Create a Thread by Implementing a Runnable Interface

 Implement a run() method provided by a Runnable interface.

 complete business logic inside this method.
 The thread can be run by passing an instance of the class to a Thread
object's constructor and then calling the thread's start () method.
 Create a Thread by Extending a Thread Class

 create a new class that extends Thread class 

 This approach is good because it provides more flexibility in handling
multiple threads
 override run( ) method available in Thread class
 can start it by calling start() method

Thread Methods

 start() isAlive()
 run() join()
 setName()
 setPriority()

Static Method:
 yield() - running thread will yield to any other threads of the same
priority that are waiting to be scheduled.
 public static boolean holdsLock(Object x)
 public static Thread currentThread()
 public static void dumpStack()

Thread Synchronization

 When we start two or more threads there may be a situation when

multiple threads try to access the same resource and finally, they can
produce wrong results.
 So, we need to synchronize the threads and make only one thread can
access the resource at a given point in time.
 Each object in Java is associated with a monitor, which a thread can lock
or unlock
 Only one thread at a time may hold a lock on a monitor.
 We can synchronize the task by using synchronized blocks.

Interthread Communication
 public void wait()
 public void notify()
 public void notifyAll()

Thread Deadlock

 two or more threads are blocked forever, waiting for each other
 Situation where threads need the same locks but obtain them in different
order.
 because the synchronized keyword causes the executing thread to block
while waiting for the lock

With Runnable

 The Runnable interface is a functional interface and has a single run()

method which doesn't accept any parameters and does not return any
values.
 This is suitable for situations where we are not looking for a result of the
thread execution, for example, incoming events logging:

With Callable:
 The Callable interface is a generic interface containing a single call ()
method – which returns a generic value V:
 The result of call () method is returned within a Future object:
- Generics

Mutable vs Immutable Objects:

 object whose internal state remains constant after it has been entirely
created. This means that once the object has been assigned to a variable,
we can neither update the reference nor mutate the internal state by any
means.
 A mutable object can be changed after it's created, and an immutable
object can't.
 In Java, everything (except for strings) is mutable by default:
 There's no way to make existing objects immutable. Even if an object is
declared final, its fields can still be changed:
 That said, if you're defining your own class, you can make its objects
immutable by making all fields final and private.
 Strings are immutable in Java.
 Any time you change a string, you're actually creating a new and separate
copy.

Why Is String Immutable in Java?

 The key benefits of keeping this class as immutable are caching, security,
synchronization, and performance.
 the JVM optimizes the amount of memory allocated for them by storing
only one copy of each literal String in the pool.
 String Buffer:
 StringBuffer in java is used to create modifiable String objects.
 This means that we can use StringBuffer to append, reverse, replace,
concatenate and manipulate Strings
 StringBuffer is much alike the String class, but with mutability features.

String Builder:

 The StringBuilder class provides no guarantee of synchronization

 If such synchronization is required, then it is recommended that
StringBuffer be used.

- Java 8 Features
Lambda expressions:

 It provides a way to represent one method interface using an expression.

 It helps to iterate, filter and extract data from collection.

Method References:

 Method reference is used to refer method of functional interface

 Each time when you are using lambda expression to just referring a
method, you can replace your lambda expression with method reference.

forEach:

 Java provides a new method forEach() to iterate the elements.

  Collection classes which extends Iterable interface can use forEach()
method to iterate elements.

Nashorn JavaScript Engine:

 Nashorn is a JavaScript engine. It is used to execute JavaScript code

dynamically at JVM (Java Virtual Machine). Java provides a command-
line tool jjs which is used to execute JavaScript code.

 You can execute JavaScript code by two ways:

 Using jjs command-line tool, and
 By embedding into Java source code.

StringJoiner:

 Java added a new final class StringJoiner in java.util package. It is used to

construct a sequence of characters separated by a delimiter. Now, you can
create string by passing delimiters like comma(,), hyphen(-) etc.

Collectors:

 Collectors is a final class that extends Object class. It provides reduction

operations, such as accumulating elements into collections, summarizing
elements according to various criteria etc.

 For more information and examples: click here

Stream API:

 Java 8 java.util.stream package consists of classes, interfaces and an

enum to allow functional-style operations on the elements. It performs
lazy computation. So, it executes only when it requires.

 For more information and examples: click here

Stream Filter:

 Java stream provides a method filter() to filter stream elements on the

basis of given predicate. Suppose, you want to get only even elements of
your list, you can do this easily with the help of filter() method.
  For more information and examples: click here

Data Structures:

- Collections (List, Set, Map, Queue)

List:
 A List is an ordered Collection
 Lists may contain duplicate elements.
 Elements can be inserted or accessed by their position in the list, using a
zero-based index.
Arraylist:
 it is based on an Array data structure
 ArrayList is a resizable-array
 permits all elements, including null.
 ArrayList can dynamically grow and shrink
Why ArrayList is better than Array?

 The limitation with array is that it has a fixed length so if it is full you
cannot add any more elements
 likewise if there are number of elements gets removed from it the
memory consumption would be the same as it doesn’t shrink.
 ArrayList can dynamically grow and shrink after addition and removal of
elements

LinkedList representation:
 Each element in the LinkedList is called the Node. Each Node of the
LinkedList contains two items:
1) Content of the element
2) Pointer/Address/Reference to the Next Node in the LinkedList
 Head of the LinkedList only contains the Address of the First element of
the List.
 The Last element of the LinkedList contains null in the pointer part of the
node because it is the end of the List so it doesn’t point to anything

Why do we need a Linked List?

 arrays have certain limitations such as size of the array is fixed
 Array elements need contiguous memory locations to store their values
 Inserting an element in an array is performance wise expensive as we
have to shift several elements to make a space for the new element
 deleting an element from the array is also a performance wise expensive
operation because all the elements have to be shifted left.

These limitations are handled in the Linked List:

 Linked list allows dynamic memory allocation, which means memory
allocation is done at the run time by the compiler and we do not need to
mention the size of the list during linked list declaration.
 Linked list elements don’t need contiguous memory locations because
elements are linked with each other using the reference part of the node
 Insert and delete operations in the Linked list are not performance wise
expensive because adding and deleting an element from the linked list
 doesn’t require element shifting, only the pointer of the previous and the
next node requires change.
ArrayList Vs LinkedList:

1) Search: ArrayList search operation is pretty fast compared to the LinkedList

search operation. get(int index) in ArrayList gives the performance of O(1)
while LinkedList performance is O(n).
Reason: ArrayList maintains index-based system for its elements as it uses
array data structure implicitly which makes it faster for searching an element.
LinkedList implements doubly linked list which requires the traversal through
all the elements for searching an element.
2) Deletion: LinkedList remove operation gives O(1) performance while
ArrayList gives variable performance: O(n) in worst case (while removing first
element) and O(1) in best case (While removing last element).
Conclusion: So LinkedList element deletion is faster compared to ArrayList.
Reason: LinkedList’s each element maintains two pointers which points to the
both neighbor elements in the list. Hence removal only requires change in the
pointer location in the two neighbor nodes. While In ArrayList all the elements
need to be shifted to fill out the space created by removed element.
3) Inserts Performance: LinkedList add method gives O(1) performance while
ArrayList gives O(n) in worst case.
4) Memory Overhead: ArrayList maintains indexes and element data while
LinkedList maintains element data and two pointers for neighbor nodes hence
the memory consumption is high in LinkedList comparatively.
When to use LinkedList and when to use ArrayList?
1) the insert and remove operations give good performance (O(1)) in LinkedList
compared to ArrayList(O(n)). So if there is a requirement of frequent addition
and deletion in application then LinkedList is a best choice.
2) Search (get method) operations are fast in Arraylist (O(1)) but not in
LinkedList (O(n)) so If there are less add and remove operations and more
search operations requirement, ArrayList would be your best bet.
Set in Java:
 Java Set is an interface that extends Collection interface.
 Set is a collection of elements that contains no duplicate elements.
  Java Set is NOT an ordered collection, its elements does NOT have a
particular order.
 We don’t have a control over the position where you can insert an
element.
 You cannot access elements by their index.

HashSet:
 The underlying data structure for HashSet is Hash table.
 HashSet stores the elements by using a mechanism called hashing.
 HashSet contains unique elements only.
 HashSet doesn't maintain the insertion order. Elements are inserted on the
basis of their hash code.
 HashSet is the best approach for search operations.
 The initial default capacity of HashSet is 16, and the load factor is 0.75.
 Default initial capacity of the HashMap takes is 16 and load factor is 0.75f (i.e 75% of current map
size). The load factor represents at what level the HashMap capacity should be doubled. For example,
product of capacity and load factor as 16 * 0.75 = 12. This represents that after storing the 12th key –
value pair into the HashMap, its capacity becomes 32.
 HashSet allows null value.
 Before storing an Object, HashSet checks whether there is an existing
entry using hashCode() and equals() methods.
 Time Complexity of HashSet Operations: The underlying data structure
for HashSet is hashtable. So amortize time complexity for add, remove
and look-up (contains method) operation of HashSet takes O(1) time.

TreeSet:
 Underlying data Structure is self-balancing tree.
 TreeSet implements the SortedSet interface. So, duplicate values are not
allowed.
 TreeSet implements a NavigableSet interface.
 The ordering of the elements is maintained by a set using their natural
ordering whether or not an explicit comparator is provided. Which means
objects in a TreeSet are stored in ascending order.
 If we are depending on default natural sorting order, the objects that are
being inserted into the tree should be homogeneous and comparable.
TreeSet does not allow to insert Heterogeneous objects. It will throw a
classCastException at Runtime if we try to add heterogeneous objects.
  TreeSet is basically an implementation of a self-balancing binary search
tree.
 Therefore, operations like add, remove, and search take O(log(N)) time.
String class and all the Wrapper classes already implements Comparable interface but
StringBuffer class doesn’t implements Comparable interface. Hence, we get a
ClassCastException in the above example.
TreeSet serves as an excellent choice for storing large amounts of sorted information which
are supposed to be accessed quickly because of its faster access and retrieval time. The
insertion of null values into a TreeSet throws NullPointerException because while insertion of
null, it gets compared to the existing elements and null cannot be compared to any value.

HashSet vs TreeSet in Java:

Speed and internal implementation
HashSet: For operations like search, insert and delete. It takes constant time for
these operations on average. HashSet is faster than TreeSet. HashSet is
Implemented using a hash table.
TreeSet: TreeSet takes O(Log n) for search, insert and delete which is higher
than HashSet. But TreeSet keeps sorted data. TreeSet is implemented using a
Self-Balancing Binary Search Tree.

Ordering
Elements in HashSet are not ordered. TreeSet maintains objects in Sorted order
defined by either Comparable or Comparator method in Java. TreeSet elements
are sorted in ascending order by default.
Null Object
HashSet allows null object. TreeSet doesn’t allow null Object and throw
NullPointerException, Because TreeSet uses compareTo() method to compare
keys and compareTo() will throw java.lang.NullPointerException.
Comparison
HashSet uses equals() method to compare two object in Set and for detecting
duplicates. TreeSet uses compareTo() method for same purpose.
If equals() and compareTo() are not consistent, i.e. for two equal object equals
should return true while compareTo() should return zero, than it will break
contract of Set interface and will allow duplicates in Set implementations like
TreeSet
LinkedHashSet:
 The LinkedHashSet is an ordered version of HashSet that maintains a
doubly linked List across all elements.
 When the iteration order is needed to be maintained this class is used.
 When iterating through a HashSet the order is unpredictable, while a
 LinkedHashSet lets us iterate through the elements in the order in which
they were inserted.
 Contains unique elements only like HashSet. It extends the HashSet class
and implements the Set interface. Maintains insertion order.

Difference and similarities between HashSet, LinkedHashSet and

TreeSet in Java
https://www.geeksforgeeks.org/difference-and-similarities-
between-hashset-linkedhashset-and-treeset-in-java/
What is the core problem that Spring Framework solves?
 Most important feature of Spring Framework is Dependency
Injection. when DI or IOC is used properly, we can develop loosely
coupled applications. And loosely coupled applications can be easily
unit Spring Boot vs Spring MVC vs Spring tested.
What else does Spring Framework solve?
 Reduce Boilerplate Code/ Reduce Duplication
 Promote Decoupling/ Increase Unit Testability

What is the core problem that Spring MVC Framework

solves?
Spring MVC Framework provides decoupled way of developing web
applications. With simple concepts like Dispatcher Servlet, ModelAndView and
View Resolver, it makes it easy to develop web applications.

Why do we need Spring Boot?

When we use Spring MVC, we need to configure component scan, dispatcher

servlet, a view resolver, web jars(for delivering static content) among other
things.
When we use Hibernate/JPA, we would need to configure a datasource, an
entity manager factory, a transaction manager among a host of other things.

Spring Boot Auto Configuration:

Spring Boot looks at
a) Frameworks available on the CLASSPATH
b) Existing configuration for the application.
Based on these, Spring Boot provides basic configuration needed to configure
the application with these frameworks.

Spring Bean:
A bean is an object that is instantiated, assembled, and otherwise managed by a
Spring IoC container.

Inversion of Control:
 Inversion of Control is a principle in software engineering which transfers
the control of to a container or framework.
 IoC enables a framework to take control of the flow of a program and
make calls to our custom code.
 is a process in which an object defines its dependencies without creating
them
 This object delegates the job of constructing dependencies to an IoC
container.
 All we need to do is to provide the container with appropriate
configuration metadata.
Dependency Injection:
 Dependency injection is a pattern we can use to implement IoC, where
the control being inverted is setting an object's dependencies.
 injecting” objects into other objects, is done by an assembler

Spring IoC Container

 ApplicationContext represents the IoC container
 Spring container is responsible for instantiating, configuring, and
assembling objects and managing their life cycles.
 The Spring framework provides several implementations of the
ApplicationContext interface
 WebApplicationContext for web applications.
Bean Configuration:
@Component: which registers the class as a component with the framework.
@Configuration: produces a bean.
@ComponentScan: instructs the container to looks for beans in the specified
package and the corresponding injected with @Autowired annotation.

Inject a dependency into component?

 Constructor-Based Dependency Injection:
@Configuration
public class AppConfig {
@Bean
public Item item1() {
return new ItemImpl1();
}
@Bean
public Store store() {
return new Store(item1());
}
}
The @Configuration annotation indicates that the class is a source of bean
definitions.
We use the @Bean annotation on a method to define a bean.
For a bean with the default singleton scope, Spring first checks if a cached
instance of the bean already exists, and only creates a new one if it doesn't. If
we're using the prototype scope, the container returns a new bean instance for
each method call. Another way to create the configuration of the beans is
through XML configuration: <bean id="item1"
class="org.baeldung.store.ItemImpl1" />

 Setter-Based Dependency Injection:

For setter-based DI, the container will call setter methods of our class after
invoking a no-argument constructor
 Field-Based Dependency Injection:
we can inject the dependencies by marking them with an @Autowired
annotation
- Hibernate and JPA
 Autowiring Dependencies:
https://www.baeldung.com/inversion-control-and-dependency-injection-in-
spring

Microservices – What? Advantages / Disadvantages?

 Microservices is an architectural style that allows components of
application to be built and deployed as independent services
 These services can be implemented using different programming
languages, databases, hardware, or software environments.
Advantages
 Flexibility: Micro-services allows applications to be built independently
in different platforms, using different programming languages and
different tech stack.
 Each of such services can be developed and deployed independently.
 This means an update to any component does not require the entire
application to come down in order to deploy that update, only the
component can be deployed
 Scalibility: Applications composed of microservices scale better since
one can scale them separately, whenever it is necessary. Instead of having
a single application running on a single server we might have components
of an application written in different programming languages, running in
different cloud instances at different locations. This allows us to scale our
application to different locations to serve whatever volume of
users/requests we need.
 Release Management: Microservice reduces the time to market. This
also allows us to explore the benefits of Continuous Integration and
Continuous Deployment.
 Testing and Debugging: Due to the distributed nature of the micro-
service, debugging microservices sometimes is easy as we can go to
specific micro-service that runs the code without the need to go through
the complete code.
How to convert Monolithic into Microservices?
 Identify logical components.
 Flatten and refactor components.
 Identify component dependencies.
 Identify component groups.
 Create an API for remote user interface.
 Migrate component groups to macroservices (move component groups to
separate projects and make separate deployments).
 Migrate macroservices to microservices.
 Repeat steps 6-7 until complete.

Cloud
- PCF / AWS / Azure / GCP / Private Cloud - Experienced? Services Offered by these platforms?

- Config Server – How to do configurations?

- Lambda (Serverless Computing) – What is and when to use?

- Registry and Discovery

- Client-Side Load Balancing (Feign Clients – Declarative / Manual)

- How to consume a public API?

- How to expose a service to Public?

- How to Document an API?

- API Gateway

- Security (OAuth, JWT)

- Logging and Log Analysis

- Actuators

- Sleuth

DB Handling

- When to use NoSQL? Why?

- Handling One to one, Many to one and Many to many Relationships.

- Compose a SQL Query for a given use case

- Lazy Loading?

- Issues with ORM tools

- Transactions
Quality / DevOps

- Unit Testing (Junit / Mockito)

- TDD (Why? / Practical Experience?)

- Code Coverage

- CI / CD using Jenkins or Equivalent

- Security Scanning

- Automation Testing

Front End Skills

Javascript Basics

- Functional Programming

- Asynchronous Programming

Angular:
Event Handling:
 target event name = emplate statement to the right
 <button (click)="onSave()">Save</button>
Custom events with EventEmitter:
 ItemDetailComponent that presents item information
 ItemDetailComponent has a delete button it doesn't contain the
functionality to delete the hero
 It can only raise an event
// This component makes a request, but it can't actually delete a hero.
 @Output() deleteRequest = new EventEmitter<Item>();
 delete() {
this.deleteRequest.emit(this.item);
}
The hosting parent component binds to the deleteRequest
<app-item-detail(deleteRequest)="deleteItem($event)"
[item]="currentItem"></app-item-detail>

Life Cycle of Components:

 starts when Angular instantiates the component class and renders the
component view along with its child views
 The lifecycle continues with change detection, as Angular checks to see
properties change and updates both the view and the component instance
as needed
 ends when Angular destroys the component instance and removes its
rendered template from the DOM
Modules:
 They can contain components, service providers,
 They can import functionality that is exported from other NgModules,
and export selected functionality for use by other NgModules.
 Every Angular app has NgModule
How components interact between Parent and Child
1. Pass data from parent to child with input binding with @Input()
decorator.
2. Intercept input property changes with ngOnChanges()
3. Intercept input property changes with a setter
4. child event

HTTP Requests:
 the HttpClient service class in @angular/common/http
 Use the HttpClient.get() method to fetch data from a server
 The asynchronous method sends an HTTP request, and returns an
Observable that emits the requested data when the response is received

Form / Form Validation:

 Instead of adding validators through attributes in the template
 add validator functions directly to the form control model in the
component class
 Angular then calls these functions whenever the value of the control
changes.

Code Splitting / Lazy Loading:

 By default, NgModules are eagerly loaded, which means that as soon as
the app loads
 For large apps with lots of routes, lazy loading is useful.
 a design pattern that loads NgModules as needed.
 Lazy loading helps keep initial bundle sizes smaller, which in turn helps
decrease load times.
 To lazy load Angular modules, use loadChildren (instead of component)
in your AppRoutingModule routes configuration
Error Handling:
 By using Angular's HttpClient along with catchError from RxJS, we can
easily write a function to handle errors within each service.
There are two categories of errors which need to be handled differently:
 Client-side: Network problems and front-end code errors. With
HttpClient, these errors return ErrorEvent instances
 Server-side: AJAX errors, user errors, back-end code errors, database
errors, file system errors. With HttpClient, these errors return HTTP Error
Responses.

Big Picture of Maven

LAZY LOADING:
 improves performance of the application by reducing network round trips
between java application and database
 hibernate doesn’t load an object from database immediately. an object
will be loaded on demand basis.
 hibernate lazy loading is true by default
@Entity
public class University {
 @Id
private String id;
private String name;

@OneToMany(fetch = FetchType.EAGER)
private List<Student> students;
}

one-to-many relationship:

 in this relationship one parent has multiple child object

To create this kind of association relationships in hibernate we need to

perform two modification:
1. in parent pojo class we must take child class as a collection properties
@OneToMany(fetch = FetchType.EAGER)
private List<Student> students;
2. In child, @manyToOne
Public parentEntity reference.

Spring Core Annotations

@Configuration
@Configuration is used on classes that define beans. @Configuration is an
analog for an XML configuration file – it is configured using Java classes. A
Java class annotated with @Configuration is a configuration by itself and
will have methods to instantiate and configure the dependencies.

@ComponentScan
@ComponentScan is used with the @Configuration annotation to allow
Spring to know the packages to scan for annotated components.
@ComponentScan is also used to specify base packages using
basePackageClasses or basePackage attributes to scan. If specific
packages are not defined, scanning will occur from the package of the
class that declares this annotation.

@Autowired
@Autowired is used to mark a dependency which Spring is going to
resolve and inject automatically. We can use this annotation with a
constructor, setter, or field injection.

@Component
@Component is used on classes to indicate a Spring component. The
@Component annotation marks the Java class as a bean or component so
that the component-scanning mechanism of Spring can add it into the
application context.

@Bean
@Bean is a method-level annotation and a direct analog of the XML
element. @Bean marks a factory method which instantiates a Spring bean.
Spring calls these methods when a new instance of the return type is
required.

@Qualifier
@Qualifier helps fine-tune annotation-based autowiring. There may be
scenarios when we create more than one bean of the same type and want
to wire only one of them with a property. This can be controlled using
@Qualifier annotation along with the @Autowired annotation.
We use @Qualifier along with @Autowired to provide the bean ID or bean
name we want to use in ambiguous situations.

@Primary
We use @Primary to give higher preference to a bean when there are
multiple beans of the same type. When a bean is not marked with
@Qualifier, a bean marked with @Primary will be served in case on
ambiquity.

@Required
The @Required annotation is method-level annotation, and shows that the
setter method must be configured to be dependency-injected with a value
at configuration time.
@Required on setter methods to mark dependencies we want to populate
through XML; Otherwise, BeanInitializationException will be thrown.

@Value
Spring @Value annotation is used to assign default values to variables and
method arguments. We can read spring environment variables as well as
system variables using @Value annotation.
We can use @Value for injecting property values into beans. It’s
compatible with the constructor, setter, and field injection.

@DependsOn
@DependsOn makes Spring initialize other beans before the annotated
one. Usually, this behavior is automatic, based on the explicit
dependencies between beans.
The @DependsOn annotation may be used on any class directly or
indirectly annotated with @Component or on methods annotated with
@Bean.

@Lazy
@Lazy makes beans to initialize lazily. By default, the Spring IoC container
creates and initializes all singleton beans at the time of application startup.
@Lazy annotation may be used on any class directly or indirectly
annotated with @Component or on methods annotated with @Bean.

@Lookup
A method annotated with @Lookup tells Spring to return an instance of the
method’s return type when we invoke it.

@Scope
@Scope is used to define the scope of a @Component class or a @Bean
definition. It can be either singleton, prototype, request, session,
globalSession or some custom scope.

@Profile
Beans marked with @Profile will be initialized in the container by Spring
only when that profile is active. By Default, all beans has “default” value as
Profile. We can configure the name of the profile with the value argument
of the annotation.

@Import
@Import allows to use specific @Configuration classes without component
scanning. We can provide those classes with @Import‘s value argument.

@ImportResource
@ImportResource allows to import XML configurations with this annotation.
We can specify the XML file locations with the locations argument, or with
its alias, the value argument.

@PropertySource
@PropertySource annotation provides a convenient and declarative
mechanism for adding a PropertySource to Spring’s Environment. To be
used in conjunction with @Configuration classes.

All About Java Regular Expressions Regex 2019

 
Spring MVC Annotations
@Controller
The @Controller annotation is used to indicate the class is a Spring
controller. This annotation is simply a specialization of the @Component
class and allows implementation classes to be auto-detected through the
class path scanning.

@Service
@Service marks a Java class that performs some service, such as
executing business logic, performing calculations, and calling external
APIs. This annotation is a specialized form of the @Component annotation
intended to be used in the service layer.

@Repository
This annotation is used on Java classes that directly access the database.
The @Repository annotation works as a marker for any class that fulfills
the role of repository or Data Access Object. This annotation has an
automatic translation feature. For example, when an exception occurs in
the @Repository, there is a handler for that exception and there is no need
to add a try-catch block.

@RequestMapping
@RequestMapping marks request handler methods inside @Controller
classes. It accepts below options:
path/name/value: which URL the method is mapped to.
method: compatible HTTP methods.
params: filters requests based on presence, absence, or value of HTTP
parameters.
headers: filters requests based on presence, absence, or value of HTTP
headers.
consumes: which media types the method can consume in the HTTP
request body.
produces: which media types the method can produce in the HTTP
response body.

@RequestBody
@RequestBody indicates a method parameter should be bound to the
body of the web request. It maps the body of the HTTP request to an
object. The body of the request is passed through an
HttpMessageConverter to resolve the method argument depending on the
content type of the request. The deserialization is automatic and depends
on the content type of the request.

@GetMapping
@GetMapping is used for mapping HTTP GET requests onto specific
handler methods.
Specifically, @GetMapping is a composed annotation that acts as a
shortcut for @RequestMapping(method = RequestMethod.GET).

@PostMapping
@PostMapping is used for mapping HTTP POST requests onto specific
handler methods.
Specifically, @PostMapping is a composed annotation that acts as a
shortcut for @RequestMapping(method = RequestMethod.POST).

@PutMapping
@PutMapping is used for mapping HTTP PUT requests onto specific
handler methods.
Specifically, @PutMapping is a composed annotation that acts as a
shortcut for @RequestMapping(method = RequestMethod.PUT).

@DeleteMapping
@DeleteMapping is used for mapping HTTP DELETE requests onto
specific handler methods.
Specifically, @DeleteMapping is a composed annotation that acts as a
shortcut for @RequestMapping(method = RequestMethod.DELETE).

@PatchMapping
@PatchMapping is used for mapping HTTP PATCH requests onto specific
handler methods.
Specifically, @PatchMapping is a composed annotation that acts as a
shortcut for @RequestMapping(method = RequestMethod.PATCH).

@ControllerAdvice
@ControllerAdvice is applied at the class level. For each controller, you
can use @ExceptionHandler on a method that will be called when a given
exception occurs. But this handles only those exceptions that occur within
the controller in which it is defined. To overcome this problem, you can
now use the @ControllerAdvice annotation. This annotation is used to
define @ExceptionHandler, @InitBinder, and @ModelAttribute methods
that apply to all @RequestMapping methods. Thus, if you define the
@ExceptionHandler annotation on a method in a @ControllerAdvice class,
it will be applied to all the controllers.

@ResponseBody
@ResponseBody on a request handler method tells Spring to converts the
return value and writes it to the HTTP response automatically. It tells
Spring to treat the result of the method as the response itself.
The @ResponseBody annotation tells a controller that the object returned
is automatically serialized into JSON and passed back into the
HttpResponse object. If we annotate a @Controller class with this
annotation, all request handler methods will use it.

@ExceptionHandler
@ExceptionHandler is used to declare a custom error handler method.
Spring calls this method when a request handler method throws any of the
specified exceptions.
The caught exception can be passed to the method as an argument.

@ResponseStatus
@ResponseStatus is used to specify the desired HTTP status of the
response if we annotate a request handler method with this annotation. We
can declare the status code with the code argument, or its alias, the value
argument.

@PathVariable
@PathVariable is used to indicates that a method argument is bound to a
URI template variable. We can specify the URI template with the
@RequestMapping annotation and bind a method argument to one of the
template parts with @PathVariable.

@RequestParam
@RequestParam indicates that a method parameter should be bound to a
web request parameter. We use @RequestParam for accessing HTTP
request parameters. With @RequestParam we can specify an injected
value when Spring finds no or empty value in the request. To achieve this,
we have to set the defaultValue argument.

@RestController
@RestController combines @Controller and @ResponseBody. By
annotating the controller class with @RestController annotation, we no
longer need to add @ResponseBody to all the request mapping methods.

@ModelAttribute
@ModelAttribute is used to access elements that are already in the model
of an MVC @Controller, by providing the model key.

@CrossOrigin
@CrossOrigin enables cross-domain communication for the annotated
request handler methods. If we mark a class with it, it applies to all request
handler methods in it. We can fine-tune CORS behavior with this
annotation’s arguments.
@InitBinder
@InitBinder is a method-level annotation that plays the role of identifying
the methods that initialize the WebDataBinder — a DataBinder that binds
the request parameter to Java Bean objects. To customize request
parameter data binding, you can use @InitBinder annotated methods
within our controller. The methods annotated with @InitBinder include all
argument types that handler methods support.

The @InitBinder annotated methods will get called for each HTTP request
if we don’t specify the value element of this annotation. The value element
can be a single or multiple form names or request parameters that the init
binder method is applied to.

How is Java Pass by Value and Not by Reference [4 Examples]

Spring Boot Annotations
@SpringBootApplication
@SpringBootApplication marks the main class of a Spring Boot application.
This is used usually on a configuration class that declares one or more
@Bean methods and also triggers auto-configuration and component
scanning.
The @SpringBootApplication annotation is equivalent to using
@Configuration, @EnableAutoConfiguration, and @ComponentScan with
their default attributes.

@EnableAutoConfiguration
@EnableAutoConfiguration tells Spring Boot to look for auto-configuration
beans on its classpath and automatically applies them. It tells Spring Boot
to “guess” how you want to configure Spring based on the jar
dependencies that you have added.
Since spring-boot-starter-web dependency added to classpath leads to
configure Tomcat and Spring MVC, the auto-configuration assumes that
you are developing a web application and sets up Spring accordingly. This
annotation is used with @Configuration.

@ConditionalOnClass and @ConditionalOnMissingClass

The @ConditionalOnClass and @ConditionalOnMissingClass annotations
let configuration be included based on the presence or absence of specific
classes. With these annotations, Spring will only use the marked auto-
configuration bean if the class in the annotation’s argument is
present/absent.

@ConditionalOnBean and @ConditionalOnMissingBean

@ConditionalOnBean and @ConditionalOnMissingBean annotations let a
bean be included based on the presence or absence of specific beans.

@ConditionalOnProperty
@ConditionalOnProperty annotation lets configuration be included based
on a Spring Environment property i.e. make conditions on the values of
properties.

@ConditionalOnResource
@ConditionalOnResource annotation lets configuration be included only
when a specific resource is present.

@ConditionalOnWebApplication and
@ConditionalOnNotWebApplication
@ConditionalOnWebApplication and @ConditionalOnNotWebApplication
annotations let configuration be included depending on whether the
application is a “web application”. A web application is an application that
uses a spring WebApplicationContext, defines a session scope, or has a
StandardServletEnvironment.

@ConditionalExpression
@ConditionalExpression is used in more complex situations. Spring will
use the marked definition when the SpEL expression is evaluated to true.

@Conditional
@Conditional is used in complex conditions, we can create a class
evaluating the custom condition.