DEV Community: Ajay Rathod

Cisco Java Developer Interview Transcript 2024(Java,Spring-Boot,Hibernate)

Ajay Rathod — Fri, 03 May 2024 08:35:21 +0000

“Hello folks, I am jotting down the full tech interview round for a Java developer position at Cisco. All these Q&A are actual questions and will immensely help you if you are looking to enter Cisco Systems. Let’s get started.”

Are you preparing for a job interview as a Java developer?
Find my book Guide To Clear Java Developer Interview here Gumroad (PDFFormat) and Amazon (Kindle eBook).
Guide To Clear Spring-Boot Microservice Interview here Gumroad (PDFFormat) and Amazon (Kindle eBook).
Download the sample copy here: Guide To Clear Java Developer Interview[Free Sample Copy]
Guide To Clear Spring-Boot Microservice Interview[Free Sample Copy]

In this interview transcript, first round was with two senior engineer, they were evaluating me for Java,Spring-boot,microservice,Database,hibernate,kafka so on and so forth.

Pro Tip:
“In one hour of interview, only important questions are always asked, and they tend to get repeated all the time. Preparing them is the key to success.”

Spring Framework and Spring Boot

What is Response Entity in Spring-Boot?
In Spring Boot, a ResponseEntity is a class used to represent the entire HTTP response sent back to a client. It goes beyond just the data itself and encapsulates three key aspects:
Status Code: This indicates the outcome of the request, like success (200 OK), not found (404), or internal server error (500).
Headers: These are optional key-value pairs that provide additional information about the response, such as content type, cache control, or authentication details.
Body: This is the actual data being sent back to the client. It can be anything from JSON or XML to plain text, depending on your API design.
By using ResponseEntity, you gain fine-grained control over how Spring Boot constructs the response. You can set the appropriate status code, add custom headers, and include the response data in the body. This allows you to build more informative and flexible APIs.

@RestController
public class ProductController {

    @GetMapping("/products/{id}")
    public ResponseEntity<Product> getProduct(@PathVariable Long id) {

        // Simulate product retrieval logic
        Product product = getProductFromDatabase(id);

        // Check if product exists
        if (product == null) {
            return ResponseEntity.notFound().build(); // 404 Not Found
        }

        // Return product with OK status (200)
        return ResponseEntity.ok(product);
    }

    // Simulate product retrieval from database (replace with your actual logic)
    private Product getProductFromDatabase(Long id) {
        // ... (implementation details)
        return new Product(id, "Sample Product", 10.0);
    }
}

How to configure multiple databases in spring-boot application?
This is very interesting question and gets repeated all the time in an interview.
Spring Boot offers a convenient way to configure multiple databases in your application. Here’s a breakdown of the steps involved:

Define Data Source Properties: Spring Boot uses properties to configure data sources. You can define them in your application.yml or application.properties file. Each data source needs its own set of properties, prefixed with a unique identifier. Common properties include: url: Database connection URL. username: Database username. password: Database password. driverClassName: JDBC driver class name for the database. Here’s an example configuration for two databases named users and orders: spring: datasource: users: url: jdbc:mysql://localhost:3306/users username: user password: password driverClassName: com.mysql.cj.jdbc.Driver orders: url: jdbc:postgresql://localhost:5432/orders username: orders_user password: orders_password driverClassName: org.postgresql.Driver
Create DataSource Beans: Spring Boot provides annotations and utilities to create DataSource beans. You can use @ConfigurationProperties to map the data source properties defined earlier to a bean. Here’s an example configuration class with DataSourceBuilder to create beans for each data source: `@Configuration public class DataSourceConfig {

@bean
@ConfigurationProperties(prefix = "spring.datasource.users")
public DataSource usersDataSource() {
return DataSourceBuilder.create().build();
}

@bean
@ConfigurationProperties(prefix = "spring.datasource.orders")
public DataSource ordersDataSource() {
return DataSourceBuilder.create().build();
}
}`

Configure Entity Manager and Transaction Manager (Optional):
If you’re using Spring Data JPA, you’ll need to configure separate Entity Managers and Transaction Managers for each data source.
These can be created similarly to DataSource beans, specifying the entities associated with each data source.

Injecting the Correct DataSource: By default, Spring Boot auto-configures a single DataSource. To use specific data sources: You can inject @Qualifier("usersDataSource") or @Qualifier("ordersDataSource") for specific repositories or services. JPA repositories can also use @Entity annotation with a entityManagerFactoryRef attribute to specify the EntityManager. Remember to adapt the configuration details (database type, connection details) to your specific databases. How to declare Global Exceptions in Springboot application?[imp question] Spring Boot offers two main approaches to declare Global Exceptions:
Using @ControllerAdvice: This is the recommended approach for centralized exception handling. Here’s how it works: Create a class annotated with @ControllerAdvice. Define methods annotated with @ExceptionHandler to handle specific exceptions. These methods can: Return a custom error response object containing details about the exception. Set a specific HTTP status code using ResponseEntity. Log the exception for further analysis.

@ControllerAdvice
public class GlobalExceptionHandler {

  @ExceptionHandler(ResourceNotFoundException.class)
  public ResponseEntity<ErrorResponse> handleResourceNotFound(ResourceNotFoundException ex) {
    ErrorResponse errorResponse = new ErrorResponse("Resource not found");
    return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
  }

  // Define methods for other exceptions you want to handle globally
}

What is Spring Bean LifeCycle?

What is IOC Containers?
An IoC Container is a software framework component that manages the objects (beans) in your application. It takes over the responsibility of creating, configuring, and assembling these objects and their dependencies.
How Does it Work?
Object Creation: Traditionally, you’d manually create objects in your code. With an IoC container, you define the objects (beans) you need in your application using configuration files (XML or annotations) or Java classes. The container then takes care of instantiating these objects.
Dependency Injection: Objects often rely on other objects to function properly (dependencies). Instead of manually creating and passing these dependencies around, you declare them in your object definitions. The IoC container injects (provides) the required dependencies to the objects it creates. This creates a loose coupling between objects, making your code more modular and easier to test.
Object Lifecycle Management: The IoC container also manages the lifecycle of objects, including initialization and destruction. This frees you from writing boilerplate code for these tasks.

What is Dependency Injections?

In software development, dependency injection (DI) is a technique for providing an object with the objects (dependencies) it needs to function. Here’s a breakdown of the key concepts:
What are Dependencies?
Dependencies are other objects that a class or function relies on to perform its work effectively.
Examples:
A car depends on an engine, wheels, and other parts to function.
A database access class depends on a database connection object to interact with the database.
What is Application Context & its's use?
In Spring Boot applications, the ApplicationContext is a central interface that plays a critical role in managing the objects (beans) used throughout your application. It’s essentially a container that provides the following functionalities:

Bean Management: The core responsibility of the ApplicationContext is to manage the objects (beans) that make up your application. These beans are typically defined using annotations or XML configuration files. The ApplicationContext takes care of creating, configuring, and assembling these beans according to the specified configuration.
Dependency Injection: Beans often rely on other beans to function properly. These are called dependencies. The ApplicationContext facilitates dependency injection by automatically providing the required dependencies to the beans it creates. This eliminates the need for manual dependency creation and management, leading to loosely coupled and more maintainable code.
Resource Access: The ApplicationContext provides access to various resources your application might need, such as property files, configuration files, and message bundles. This simplifies resource retrieval and ensures consistent access throughout your code. How to Enable multiple Eureka Servers? This article deals with this question https://medium.com/become-developer/how-to-work-with-multiple-instances-of-eureka-naming-server-to-avoid-a-single-point-of-failure-d953544281d0?source=post_page-----34ed516ae32d--------------------------------

What is the difference between Spring Filter and Spring Interceptors?(This is good question to check your Spring MVC framework related concepts)
HandlerInterceptor is basically similar to a Servlet Filter, but in contrast to the latter it just allows custom pre-processing with the option of prohibiting the execution of the handler itself, and custom post-processing. Filters are more powerful, for example they allow for exchanging the request and response objects that are handed down the chain. Note that a filter gets configured in web.xml, a HandlerInterceptor in the application context.
As a basic guideline, fine-grained handler-related pre-processing tasks are candidates for HandlerInterceptor implementations, especially factored-out common handler code and authorization checks. On the other hand, a Filter is well-suited for request content and view content handling, like multipart forms and GZIP compression. This typically shows when one needs to map the filter to certain content types (e.g. images), or to all requests.
So where is the difference between Interceptor#postHandle() and Filter#doFilter()?
postHandle will be called after handler method invocation but before the view being rendered. So, you can add more model objects to the view but you can not change the HttpServletResponse since it's already committed.
doFilter is much more versatile than the postHandle. You can change the request or response and pass it to the chain or even block the request processing.
Also, in preHandle and postHandle methods, you have access to the HandlerMethod that processed the request. So, you can add pre/post-processing logic based on the handler itself. For example, you can add a logic for handler methods that have some annotations.
As the doc said, fine-grained handler-related pre-processing tasks are candidates for HandlerInterceptor implementations, especially factored-out common handler code and authorization checks. On the other hand, a Filter is well-suited for request content and view content handling, like multipart forms and GZIP compression. This typically shows when one needs to map the filter to certain content types (e.g. images), or to all requests.
Why to use @Transactional annotation what's the benefit?(In spring interview @Transactional annotation is always asked)
@Transactional is a Spring annotation that can be applied to methods or classes to indicate that the annotated code should be executed within a transaction. When Spring encounters the @Transactional annotation, it automatically creates a transaction around the annotated code and manages the transaction lifecycle.
By default, @Transactional creates a transaction with the default isolation level (usually READ_COMMITTED) and the default propagation behavior (REQUIRED). However, you can customize these settings by passing parameters to the annotation.
Here’s an example of using @Transactional in a Spring service class:
`@Service
public class UserService {

@Autowired
private UserRepository userRepository;

@Transactional
public void createUser(String name, String email) {
    User user = new User(name, email);
    userRepository.save(user);
}

In this example, the createUser() method is annotated with @Transactional, which means that the save() method of the UserRepository will be executed within a transaction.
Advantages of @Transactional:
The @Transactional annotation provides several benefits:
Simplifies transaction management: By using @Transactional, you can avoid writing boilerplate code to create and manage transactions manually. Spring takes care of transaction management for you, so you can focus on writing business logic.
Promotes consistency and integrity: Transactions ensure that multiple database operations are executed atomically, which helps to maintain data consistency and integrity.
Improves performance: Transactions can improve database performance by reducing the number of round trips between the application and the database.
Supports declarative programming: With @Transactional, you can use declarative programming to specify transaction management rules. This makes your code more concise and easier to read.

If there is Memory Leak in your application how will you find it?
Symptoms of a Memory Leak
Severe performance degradation when the application is continuously running for a long time.
OutOfMemoryError heap error in the application.
Spontaneous and strange application crashes.
The application is occasionally running out of connection objects.
What is the use of Stringtokenizer?
The string tokenizer class allows an application to break a string into tokens. The tokenization method is much simpler than the one used by the StreamTokenizer class. The StringTokenizer methods do not distinguish among identifiers, numbers, and quoted strings, nor do they recognize and skip comments.
The set of delimiters (the characters that separate tokens) may be specified either at creation time or on a per-token basis.
An instance of StringTokenizer behaves in one of two ways, depending on whether it was created with the returnDelims flag having the value true or false:
If the flag is false, delimiter characters serve to separate tokens. A token is a maximal sequence of consecutive characters that are not delimiters.
If the flag is true, delimiter characters are themselves considered to be tokens. A token is thus either one delimiter character, or a maximal sequence of consecutive characters that are not delimiters.
A StringTokenizer object internally maintains a current position within the string to be tokenized. Some operations advance this current position past the characters processed.
A token is returned by taking a substring of the string that was used to create the StringTokenizer object.
The following is one example of the use of the tokenizer. The code:
StringTokenizer st = new StringTokenizer("this is a test");
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
}
What is Spring Security Context?
SecurityContext — is obtained from the SecurityContextHolder and contains the Authentication of the currently authenticated user. Authentication — Can be the input to AuthenticationManager to provide the credentials a user has provided to authenticate or the current user from the SecurityContext .

Thanks for reading folks

full article on medium - https://medium.com/@rathod-ajay/cisco-java-developer-interview-transcript-2024-java-spring-boot-hibernate-34ed516ae32d

How I got more than 10 offer letters as a Java Developer in 3 months.

Ajay Rathod — Sat, 15 Apr 2023 08:31:54 +0000

I will be sharing my preparation strategy for techies who wants to hunt for their next tech job, during 3 months of time I have prepared extensively for a Java developer role. It helped me to clear many interviews including BIG FOUR companies. Developers who is having 0–10 years of experience can apply this strategy.

Disclaimer - This article is not for FAANG companies, I am talking about general tech companies like MNCs' small-scale to Big scale of the Indian job Market.

Here in this article, I will be elaborating on interview preparation plus my strategies about how to maximize your chance of getting selected for an interview.

Typical Interview format

Technical Round 1 (L1 round)
Technical Round 2 (L2 round)
Manager Round
HR round

Typically if you can clear the technical round you are good to go for an offer letter as manager and HR rounds are mostly discussions. We need to prepare for technical rounds only

Technical Round preparation steps

Typically interview starts with your intro and the interviewer may ask you about the project that you have been working on.
Step 1. Know the project that you have working on, of the current job in and out. We should be able to talk about the below things.
a. Projects Functionality including what it does, and what problem it solves for customers, Basically you should know your project functional overview.
b. Know your project Architecture and Technical stack. Also, you can dig deeper to know about flow end to end.
c. Technical Stack wise talk about what has been used in the project. Like Which front-end is used(angular, react), which backend is used(like Java, Python), and which Database(Postgres, DynamoDB).
d. What kind of CI-CD model is used here, like the deployment part that developers are mostly unaware of?
The above project-related stuff should be thoroughly studied by you so that you can drive the interview on your side, This is important, remember your answers generally drives the interview.
Step 2. As a Java Developer, you should know the below topics which will increase your chance of getting selected.

Object Oriented programming topics including SOLID principles. (prepare for inheritance puzzles)
Multithreading and Concurrency(prepare for Executor framework and concurrency API
Collection framework (Prepare for the internal working of each collection data structure like HashMap, Concurrent hashmap, HashSet)
Serialization (How it works)
Design Patterns (prepare at least 4–5 design patterns like creational, behavioral, and structural patterns)
Garbage Collections
Java Generics
Java 8 (Stream and Functional Programming-prepare for Java 8 coding programs on streams)
SQL Queries (prepare to write queries on JOINS and employee table like highest salary and all)
Coding practice (prepare Array and String problems as much as you can)
Memory Management (Know about Java 8 and above version memory management changes)

The above area is a must to clear the interview. Generally, a candidate gets selected based on his practical knowledge, and if he is good at writing programs and SQL queries using java he can clear interviews easily.

I have followed one strategy which is, to be positive and try to give as many interviews as I can. You may get rejected initially but. My personal Observation is if you give 10 interviews 1–2 interviews get cleared. Give as many interviews as you can. It worked for me as well.
I must have given more than 40–50 interviews, which helped me to get the maximum offer.

Interview Preparation guides for Java Developers

Guide To Clear Java Developer Interview
Free sample copies:
Grokking the Java Interview [Free Sample Copy]
Grokking the Spring Boot Interview [Free Sample Copy]

Find More article on my Medium page Medium page

Thanks for reading !!

How I Learned Java in Depth by preparing for Java Technical Interviews

Ajay Rathod — Tue, 04 Apr 2023 10:41:18 +0000

This is based on my personal experience. How I Learned Java in Depth while preparing for Java Developer Technical interviews. I will share my Takeaways from it. It helped me to gain more knowledge and Triple my Salary in less time. Since the demand for Java professionals is huge in the Market.

I assume my readers are mostly Java Developer professionals or developers, Who are seeking to expand their knowledge base so that they can excel in their current or next role.

How My Java Interview prep helped me to learn more in depth

When I started working as a Junior Java dev back in my initial days, early in my career. Whenever I was working on a task, I used to do a lot of googling for every coding logic that I can find over the internet. I was more of a stack overflow engineer.

Having a mentor in the early days is a very fortunate thing to have. They can guide you correctly rather than spending more time googling and completing the task. But I was not that lucky on that front.

When I started hunting for my next job, I got a lot of rejections and humiliation in technical rounds, because whatever I have learned was superficial only.

After a few months of preparation and facing the interviews, I got to know the value of five things that makes the difference in the technical interview and that was,

Reading Java API documentation helped to understand the underlying API of JDK. like how they internally work, and what time and space complexities they have when we use them in code.
Reading good books on Java like Head First Java and Effective java built my Object-oriented programming basics plus added a base to my Java knowledge. I assure you these books will definitely lay a strong foundation for your profile.

When we work on a project we don't pay attention to what is the best practices we should be following while writing code. we were solely focusing on getting the job done. We always write code in a brute force way and not in an optimized way if you working for NON-FAANG companies. In a coding interview, I have been always asked about the optimized code.

So solving coding puzzles/problems on leet-code and hacker rank helped me to write better code.

Design patterns and System design questions were asked most of the time. While facing the interview I got to know the importance of them and I have added them to my knowledge base as well
Importance of Unit testing, sometimes interviewers test your unit testing knowledge. I had to learn the Junit framework in depth because of that.

Topics which i learned in Depth while preparing java technical interview

Core Java API (Collection framework, Stream, Java Lang Package, Java Util Package, Java Time Package, Java IO Package, Java net Package, Java SQL Package)
Design patterns (Builder, factory, proxy, adaptor, facade, observer design patterns)with examples.
SOLID Design principles with their practical use in coding.
Read Clean code and clean coder of uncle bob which added clean coding habits (fewer WTFs in my Code reviews after that :))
Spring Framework, Hibernate framework, and JPA in depth
A unit testing framework that I have learned was, J-UNIT, MOCKITO, and POWER MOCK. which helped to clear the code coverage criteria in my pipeline.
Unless I have given the interviews I would not have studied the above topics in depth which are very important as a developer.

After learning all of those in a theoretical and practical way I was able to clear more technical rounds and I was able to triple my salary in less time span. also, I was recognized in my next role as a Strong technical resource.

One of the comments that my manager gave me in my appraisal was.

“Ajay is Technically very good and he provides quality code in a timely manner”.
That was encouraging to me, how your preparation also makes you a good developer. I hope this helps my fellow readers in their path.

If you are preparing for a Java Springboot microservice interview look no further to add the below book to your prep material, it has 250+ interview questions and answers asked in an interview.

Guide To Clear Java Developer Interview:

Gumroad Link — Gumroad

Amazon Link — Amazon

Follow me: LinkedIn | Twitter | Medium