1.What is Hibernate ?

(2 Marks)
Hibernate is a Java framework for Object-Relational Mapping (ORM). It is used in Java development to
simplify database interactions by allowing developers to work with Java objects rather than writing
SQL queries directly. This improves code maintainability and reduces the need for manual database
handling.

(5 Marks)
Hibernate is a powerful and widely-used framework in Java development for Object-Relational
Mapping (ORM). It provides a way to map Java objects to database tables and vice versa, allowing
seamless interaction between Java applications and relational databases.
Here are some key points about Hibernate:
Object-Relational Mapping (ORM): Hibernate simplifies the process of database interaction by
abstracting away the low-level SQL code. Instead, developers can work with Java objects, which are
more intuitive and easier to manage.
Cross-Database Compatibility: Hibernate is database-agnostic, meaning it can work with various types
of databases without significant changes to the codebase. This makes it highly adaptable to different
project requirements.
Automatic Table Generation: Hibernate can automatically generate database tables based on Java
objects, reducing the need for manual table creation and maintenance.
Simplified Query Language (HQL): It provides its own query language called HQL (Hibernate Query
Language) which is similar to SQL but operates on Java objects rather than database tables.
Caching Mechanisms: Hibernate supports caching, which can significantly improve performance by
reducing the need for repeated database queries.
Lazy Loading: It allows the loading of associated objects on-demand, which can lead to more efficient
memory usage in applications.
Transaction Management: Hibernate handles database transactions, ensuring data integrity and
consistency.
Integration with Java EE and Spring: Hibernate integrates seamlessly with Java EE and Spring
frameworks, making it a popular choice in enterprise-level applications.

//////////////////////////////////////////////////

2. What is Ioc Container?

(2-Mark)
An IoC (Inversion of Control) container in Java is a software framework used to manage the
instantiation, configuration, and assembly of application components. It controls the flow of a
program and reduces the dependency on programming code, enabling loose coupling between
different components. IoC containers implement the principle of Inversion of Control, where the
control over object creation and management is delegated to the container rather than the
application.

(5-Marks)
Principle of Inversion of Control (IoC): The IoC principle signifies the inversion of traditional software
design control. In the conventional approach, a program controls the flow and instantiation of its
components. With IoC, the control shifts to a container or framework, which manages the creation
and lifecycles of objects, and the wiring between different components.

Loose Coupling: IoC containers promote loose coupling between components. Classes and modules
are not directly dependent on the concrete implementations of their dependencies, but rather
depend on abstractions or interfaces. This allows for easier maintenance, testing, and modifications,
as components can be replaced or changed without affecting other parts of the system.
Dependency Injection: A key feature of IoC containers is dependency injection. Dependencies
required by an object are provided to it at runtime. This is typically achieved through constructor
injection, setter injection, or method injection. The IoC container handles the management and
injection of these dependencies, reducing the burden on the developer.

Configuration Management: IoC containers typically provide a way to configure the components and
their dependencies. This configuration can often be externalized, allowing changes to be made
without altering the application's source code. XML, annotations, or Java-based configurations are
commonly used for this purpose.

Popular IoC Containers in Java: There are several IoC containers available in the Java ecosystem.
Examples include Spring Framework's IoC container (Spring IoC), Google Guice, Apache DeltaSpike,
and others. These containers provide a rich set of features for managing the lifecycle and
dependencies of objects in a Java application.

//////////////////////////////////////////////////

3. What is default constructor ?

(2 Marks)
In Java, a default constructor is a no-argument constructor that is automatically created by the
compiler if no constructor is explicitly defined within a class. If a class does not contain any
constructor, Java provides a default constructor that initializes the objects of that class. The default
constructor has no parameters and its main purpose is to initialize instance variables with default
values (e.g., numeric types to 0, objects to null, etc.).

(5 Marks)
In Java, a constructor is a special type of method used to initialize objects. If a class does not explicitly
define any constructor, Java automatically provides a default constructor. The default constructor is
called when an object of the class is created using the new keyword without any arguments. For
example:

public class MyClass {

// Default constructor is automatically provided if no constructor is explicitly defined
}

// Usage of the default constructor

MyClass obj = new MyClass(); // This invokes the default constructor

The default constructor is essential for initializing instance variables to their default values. If a class
explicitly defines any constructor (with arguments), the default constructor is not provided by the
compiler. It's important to note that once you create a constructor with arguments in a class, the
default constructor must be manually defined if needed.

public class MyClass {

private int number;

// Constructor with arguments

public MyClass(int number) {
this.number = number;
}

// Manual creation of default constructor

public MyClass() {
// Default constructor that initializes variables
this.number = 0; // Default value
 }
}

The default constructor serves as a fallback initialization method when no other constructor is
specified within the class.

//////////////////////////////////////////////////

4. What is annotations in spring boot ?

(2 Marks)
@RestController: This annotation is used to define a class as a controller in Spring Boot that handles
incoming HTTP requests. It automatically maps the HTTP requests to handler methods and sends the
response back to the client in the form of JSON/XML, depending on the request.

@Autowired: An annotation used for automatic dependency injection in Spring. It allows Spring to
resolve and inject collaborating beans into your bean. It removes the need for explicit getters and
setters.

(5 Marks)
@SpringBootApplication: This annotation combines three annotations: @Configuration,
@EnableAutoConfiguration, and @ComponentScan. It marks the main class as the entry point for the
Spring Boot application. It enables the auto-configuration feature and component scanning. This
annotation reduces the boilerplate code and simplifies the setup of a Spring application.

@RequestMapping: This annotation is used at the method level in a controller to map web requests
to specific handler methods. It allows you to define how an HTTP request should be handled,
specifying the URL path and HTTP methods (GET, POST, PUT, DELETE, etc.) that the method will
respond to.

@Service: This annotation is used to mark a class as a service bean in the Spring framework. Service
classes hold the business logic and are often used in the service layer of a Spring application. It allows
for automatic detection and registration of beans during component scanning.

@Repository: Used to indicate that the class is a repository or a data access object in the Spring
application. It helps in translating exceptions thrown by persistence technologies into Spring's unified
unchecked exceptions. The @Repository annotation is a specialization of the @Component
annotation intended for the persistence layer.

@Transactional: This annotation is used to declare a transactional method in Spring. It ensures that a
method or a group of methods runs within a transactional context. It manages the opening and
closing of transactions, and if an exception occurs within the transactional method, it rolls back the
transaction.

//////////////////////////////////////////////////

5. What is MVC Architecture ?

(2 Marks)
MVC (Model-View-Controller) is a software architectural design pattern used to separate an
application into three interconnected components:

Model: Represents the application's data and business logic. It retrieves and manipulates data,
responding to requests from the Controller.

View: Represents the user interface (UI) and displays data from the Model. It receives input from
users and sends it to the Controller.

Controller: Acts as an intermediary between the Model and the View. It processes user input,
interacts with the Model to retrieve data, and updates the View accordingly.

In Java, the Model consists of Java classes representing data and business logic. Views are often
created using Java's Swing, JavaFX, or JSP (JavaServer Pages), responsible for displaying information to
the user. Controllers in Java are implemented using Java classes that handle user input and update
the Model and View.

(5 Marks)
Model: In a Java application following MVC, the Model represents the data structure and the business
logic. It typically consists of Java classes that encapsulate data, manage database operations, perform
calculations, and enforce the application's rules. For example, in a banking application, a BankAccount
class might represent the Model, handling account information, transactions, and balances.

View: Views in Java MVC are the UI components responsible for displaying information to the user. In
Swing or JavaFX, a View can be created using components like JFrame, JPanel, or controls like buttons
and text fields. Java Server Pages (JSP) can also serve as Views in web applications, rendering HTML
for the user's browser. These Views access the Model to fetch necessary data for display and may
send user input to the Controller for processing.

Controller: Controllers in Java MVC receive and process user input. They interpret actions initiated by
the user through the View, interact with the Model to fetch or manipulate data, and update the View
accordingly. In a Java application, a Controller class might contain event handling methods,
responding to user actions such as button clicks or form submissions. It manipulates the Model,
making necessary changes and updates before notifying the View to display the modified data.

In a Java MVC application, the components remain decoupled: the Model doesn’t communicate
directly with the View, ensuring separation of concerns and easy maintenance. The Controller
facilitates the interaction between the Model and the View, managing the application flow and
responding to user actions.

This architectural pattern enhances the maintainability, scalability, and reusability of Java applications
by separating concerns and promoting a clear division of responsibilities among the components.

//////////////////////////////////////////////////

6. What is use of annotations ?

(2 Marks)
Metadata Attachment: Annotations in Java are used to attach metadata or additional information to
code elements. They begin with the @ symbol followed by the annotation name.
Code Customization: Annotations are used to customize and configure the behavior of various
frameworks and libraries, such as Spring, Hibernate, and JUnit.
(5 Marks)
Metadata and Documentation: Annotations serve as a way to attach metadata and documentation to
Java code. They allow developers to include information about the code's purpose, behavior, and
special requirements. This metadata can be used by tools and frameworks to generate
documentation or provide additional features.

Code Analysis and Verification: Annotations are often used for code analysis and verification. For
example, the @Override annotation indicates that a method is intended to override a method from a
superclass, helping to catch compile-time errors if the method signature doesn't match correctly.

Customization with Frameworks: Many Java frameworks and libraries use annotations to configure
and customize their behavior. For example, the Spring Framework uses annotations like @Autowired
and @RequestMapping to define dependency injection and URL mappings, respectively.

Testing and Test Frameworks: Annotations are commonly used in testing frameworks like JUnit.
Annotations such as @Test mark methods as test cases, allowing the test framework to identify and
execute them during test runs.

Reducing Boilerplate Code: Annotations can help reduce boilerplate code. For instance, the @Entity
annotation in Java Persistence API (JPA) eliminates the need to write extensive database mapping
code, making data modeling more concise and readable.

//////////////////////////////////////////////////

7. What is entity class and reposistry class ?

(2 Marks)
Entity Class:
Entity class represents a real-world object stored in a database. It defines the structure and behavior
of objects that map to database records. It's crucial for ORM frameworks.

Repository Class:
Repository class provides a simplified interface for database operations. It manages the persistence
and retrieval of objects from a data source, promoting clean code organization.

(5 Marks)
Entity Class:

An entity class in Java typically represents a real-world object or concept within an application. It is
often used in the context of object-relational mapping (ORM) frameworks like Hibernate or JPA. An
entity class defines the structure and behavior of an object that will be persisted in a database. It
usually maps to a database table, with each instance of the class corresponding to a row in that table.
Entity classes typically have attributes that represent table columns and methods to interact with the
data. They are annotated with ORM-specific annotations to specify the mapping between the class
and the database table. Entity classes play a crucial role in enabling the manipulation of database
records as Java objects, simplifying database operations and making the code more object-oriented.

Repository Class:

A repository class in Java is a design pattern used for managing the persistence and retrieval of
objects, often associated with database operations. It acts as an intermediary between the
application's business logic and the data source (usually a database). Repository classes provide a
clean and consistent API for performing CRUD (Create, Read, Update, Delete) operations on entity
objects. They encapsulate the logic for querying the database, handling transactions, and converting
database records into domain objects (entities). Repository classes abstract away the complexities of
database access, promoting separation of concerns and maintainability in the codebase. This pattern
is commonly used in applications to improve data access and management.

////////////////////////////////////////////////

8. What is JDBC connection in hibernate ?

(2 Marks)
Hibernate's JDBC connection:
Hibernate abstracts JDBC (Java Database Connectivity) in Java, simplifying database access. It
manages connection pooling and configuration, allowing developers to work with Java objects rather
than low-level SQL. This abstraction enhances performance and maintains data consistency.

(5 Marks)
To establish a JDBC connection using Hibernate, you typically need to set up your Hibernate
configuration and define entity classes (POJOs) that correspond to your database tables. Here are the
basic steps to establish a JDBC connection using Hibernate:

1. **Create a Hibernate Configuration File**:

Create a Hibernate configuration file, usually named `hibernate.cfg.xml`. This file contains the
database connection information, dialect, and other Hibernate properties.

```xml
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property
name="hibernate.connection.url">jdbc:mysql://localhost:3306/your_database</property>
<property name="hibernate.connection.username">your_username</property>
<property name="hibernate.connection.password">your_password</property>
<!-- Other Hibernate properties -->
</session-factory>
</hibernate-configuration>
```

2. **Define Entity Classes**:

Create Java classes (entity classes) that map to your database tables. Annotate these classes with
Hibernate annotations to specify the mapping between class properties and table columns.

```java
import javax.persistence.*;

@Entity
@Table(name = "your_table")
public class YourEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private int id;

@Column(name = "name")
private String name;

// Constructors, getters, and setters

}
 ```

3. **Create a Hibernate Session Factory**:

In your application code, create a Hibernate Session Factory, which is a heavyweight object that
manages Hibernate sessions.

```java
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

private static final SessionFactory sessionFactory = new
Configuration().configure("hibernate.cfg.xml").buildSessionFactory();

public static SessionFactory getSessionFactory() {

return sessionFactory;
}
}
```

4. **Use Hibernate Sessions**:

To perform database operations, open a Hibernate session, begin a transaction, and use the session
to perform CRUD operations. Then, commit or roll back the transaction as needed.

```java
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();

try {
Transaction transaction = session.beginTransaction();

// Perform database operations (e.g., save, update, delete, query)

transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
} finally {
session.close();
}
```

Hibernate will handle the underlying JDBC connection and SQL operations for you, allowing you to
work with Java objects and entities directly.

/////////////////////////////////////////////////

9. What is dependency injection ?

(2 Marks)
Dependency injection in Java is a design pattern that separates the creation and management of
object dependencies from the dependent objects themselves, promoting flexibility and
maintainability. It is typically implemented through techniques like constructor injection and is often
facilitated by frameworks like Spring.
(5 marks)
Dependency Injection is a design pattern used by the Spring Framework to achieve loose coupling and
manage dependencies in a Java application. It involves injecting objects (dependencies) into a class
rather than having the class create them.

Key Components:
Bean: In Spring, a bean is a Java object managed by the Spring IoC container. These beans are
configured in a Spring configuration file and injected into other beans.

Spring IoC Container: This container manages the instantiation, configuration, and assembly of beans.
It is responsible for injecting dependencies when a bean is created.

ApplicationContext: The ApplicationContext is a specific type of IoC container that provides additional
features like internationalization, event propagation, and application layer specific contexts.

Advantages:

Reduced Coupling: DI promotes loose coupling between components, making it easier to swap out or
change dependencies without impacting the overall structure of the application.

Easier Testing: By injecting mock or stub implementations during testing, DI facilitates unit testing of
individual components.
Configurability: Dependencies can be configured externally, allowing for different configurations for
different environments (e.g., development, testing, production).

Types of Dependency Injection in Spring:

Constructor Injection: Dependencies are provided through the class constructor.

Setter Injection: Dependencies are set through setter methods.
Method Injection: Dependencies are injected through specific methods.

Conclusion:
Dependency Injection is a powerful technique in Spring, enabling flexible and maintainable
application design. It promotes best practices such as loose coupling and facilitates effective unit
testing, making it a cornerstone of Spring-based Java development.

/////////////////////////////////////////////////

10. What is beans scope ?

(2 Marks)
In Java, "bean scope" refers to the lifespan and visibility of JavaBeans. There are different scopes like
Singleton (one instance shared throughout), Prototype (new instance per request), Request (new
instance per HTTP request), Session (one per user session), and Application (one for the entire
application). The choice of scope depends on usage and requirements.

(5 Marks)
In Java, the term "bean scope" refers to the lifecycle and visibility of JavaBeans within a Java
application. JavaBeans are reusable software components that follow certain conventions and can be
used in various applications. They are typically instantiated and managed by a framework like Spring.
There are various bean scopes available, including:

Singleton: In this scope, a single instance of the bean is created and shared throughout the
application. It is the default scope in Spring, and the same bean instance is reused whenever it is
needed.
```java
 @Component
public class MySingletonBean {
// ...
}
```

Prototype: In this scope, a new instance of the bean is created every time it is requested. Each
request for the bean results in a unique instance, making it useful for stateful beans.
```java
@Component
@Scope("prototype")
public class MyPrototypeBean {
// ...
}
```

Request: This scope is typically used in web applications and creates a new instance of the bean for
each HTTP request. Once the request is complete, the bean is destroyed.
```java
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode =
ScopedProxyMode.TARGET_CLASS)
public class MyRequestScopedBean {
// ...
}
```

Session: In a web application, a session-scoped bean is created once per user session. It remains in
memory for the entire session's duration.
```java
@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode =
ScopedProxyMode.TARGET_CLASS)
public class MySessionScopedBean {
// ...
}
```

Application: This scope creates a single instance of the bean for the entire web application. It is useful
for storing application-level data.
```java
@Component
@Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode =
ScopedProxyMode.TARGET_CLASS)
public class MyApplicationScopedBean {
// ...
}
```

The choice of bean scope depends on the specific requirements of the application and how the beans
should be managed and shared among different parts of the code.

Made by @vivek_saiyan