Spring boot With Hibernate Configuration ?

Spring boot With Hibernate Configuration:

To configure Spring Boot with Hibernate, you need to follow these steps

Spring Boot Annotation List?

Spring Boot With MongoDB?

Step 1: Add Dependencies Make sure you have the necessary dependencies in your project's build file (e.g., Maven or Gradle). You will need the following dependencies:

For Maven:

xml
<dependencies>

    <!-- Spring Boot Starter Data JPA -->

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-data-jpa</artifactId>

    </dependency> 
<!-- Hibernate Entity Manager -->

    <dependency> 
<groupId>org.hibernate</groupId>

        <artifactId>hibernate-core</artifactId>

    </dependency>

    <!-- Database Driver (e.g., MySQL) -->

    <dependency>

        <groupId>mysql</groupId>

        <artifactId>mysql-connector-java</artifactId>

    </dependency>

</dependencies>

For Gradle:

groovy
dependencies { 
 // Spring Boot Starter Data JPA
    implementation 
'org.springframework.boot:spring-boot-starter-data-jpa' 
 // Hibernate Entity Manager
    implementation 
'org.hibernate:hibernate-core' 
 // Database Driver (e.g., MySQL)
    implementation 
'mysql:mysql-connector-java'
 }

Step 2: Configure Database Properties In your application.properties (or application.yml) file, provide the necessary database configuration properties. For example, if you are using MySQL, you may configure the properties as follows:

For application.properties:

properties
spring.datasource.url=jdbc:mysql://localhost:3306/db_name
 spring.datasource.username=db_username 
spring.datasource.password=db_password 
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect

For application.yml:

yaml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_name 
username: db_username

    password: db_password 
jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect

Replace db_name, db_username, and db_password with your actual database name, username, and password.

Step 3: Define an Entity Class Create an entity class that represents a table in your database. For this example, let's create a Product entity class with an id, name, and price fields.

java
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType; 
import javax.persistence.Id; 
@Entity 
public class Product { 
@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
private Long id; 
private String name;
private double price; 
// Constructors, getters, and setters

}

Step 4: Create a Repository Interface: Create a repository interface by extending the JpaRepository interface provided by Spring Data JPA. This interface will handle the CRUD operations for the Product entity.

java
import org.springframework.data.jpa.repository.JpaRepository;
public interface ProductRepository extends JpaRepository<Product, Long> {
}

Step 5: Implement a Service Layer: Create a service class that will handle business logic and interact with the repository. Here's an example ProductService class:

java
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import java.util.List;
@Service 
public class ProductService { 
private final ProductRepository productRepository;
@Autowired 
public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
 }
public List<Product> getAllProducts() { 
return productRepository.findAll(); 
 }
public Product getProductById(Long id) { 
return productRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Product not found with id: " + id));
 } 
public Product saveProduct(Product product) {
return productRepository.save(product);
 } 
public void deleteProduct(Long id) {
 productRepository.deleteById(id); 
 } 
}

Step 6: Create RESTful Endpoints: Create a RESTful controller to handle HTTP requests and map them to the appropriate methods in the ProductService class. Here's an example:

java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController

@RequestMapping("/api/products")

public class ProductController { 
private final ProductService productService; 
@Autowired 
public ProductController(ProductService productService) {
this.productService = productService; 
 } 
@GetMapping

    public List<Product> getAllProducts() { 
return productService.getAllProducts(); 
 }
@GetMapping("/{id}")

    public Product getProductById(@PathVariable Long id) { 
return productService.getProductById(id); 
 } 
@PostMapping

    public Product createProduct(@RequestBody Product product) {
return productService.saveProduct(product); 
 } 
@DeleteMapping("/{id}")

    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
 }
}

Step 7: Run the Application: You can now run your Spring Boot application. Hibernate will automatically create the necessary database tables based on your entity definitions. You can test the RESTful endpoints using a tool like Postman or by making HTTP requests.

Typically, the main class is annotated with @SpringBootApplication, which is a convenience annotation that combines several annotations, including @Configuration, @EnableAutoConfiguration, and @ComponentScan.

Here's an example of a typical Spring Boot main class:

java
import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication 
@ComponenetScan("org.springframework.*")
public class YourApplicationNameApplication { 
public static void main(String[] args) {
        SpringApplication.run(YourApplicationNameApplication.class, args);
 }
}

In this example, YourApplicationNameApplication is the name of the main class. You should replace it with an appropriate name for your application.

This example demonstrates the basic setup of Spring Boot with Hibernate