JDBCTemplate / HibernateTemplate / MongoTemplate / KafkaTemplate

 

Template	Description
JdbcTemplate	JdbcTemplate is a core class provided by the Spring JDBC module. It acts as a helper class that simplifies the use of JDBC (Java Database Connectivity) for accessing relational databases. It handles the creation and release of resources (like connections, statements, result sets), eliminates boilerplate code, and provides a consistent and cleaner approach to writing data access logic.
HibernateTemplate	HibernateTemplate is a class provided by Spring ORM module that simplifies interactions with the Hibernate ORM (Object-Relational Mapping) framework. It automates the process of Managing Hibernate sessions, transactions, handling exceptions and performing common CRUD operations on persistent entities. It abstracts repetitive Hibernate boilerplate code and provides a convenient template-style programming model for working with Hibernate.
MongoTemplate	MongoTemplate is a core class provided by the Spring Data MongoDB project. It simplifies and standardizes interactions with MongoDB databases by abstracting away the complexities of the low-level MongoDB Java Driver. It provides a template-based programming model, similar to JdbcTemplate and HibernateTemplate, enabling developers to perform CRUD operations, aggregation, pagination, query creation, and more using Java objects (POJOs).
KafkaTemplate	KafkaTemplate is a core class provided by Spring for Apache Kafka that simplifies sending messages to Kafka topics. It acts as a high-level abstraction over the native Kafka Producer API, making it easier to publish messages from a Spring Boot application. It is the Kafka equivalent of JdbcTemplate or MongoTemplate, offering a template-style programming model for sending messages to Kafka.

1)JdbcTemplate in Spring Framework

JdbcTemplate is a core class provided by Spring JDBC for simplifying database access. It handles the creation and release of resources, and provides methods for executing SQL queries, updates, and stored procedures, as well as for mapping ResultSets to objects.

---

🔷 Why use JdbcTemplate?

1. ✅ Eliminates boilerplate code (e.g., connection handling, statement closing).

2. ✅ Integrates seamlessly with Spring's transaction management.

3. ✅ Helps in writing cleaner, maintainable, and testable code.

4. ✅ Provides callback interfaces (like RowMapper, ResultSetExtractor) for custom result mapping.

---

🔷 Common Methods in JdbcTemplate

Method	Description
query()	Runs a SELECT query and maps each row using a RowMapper.
queryForObject()	Runs a SELECT query expecting a single result.
queryForList()	Returns a list of rows (each row as a Map or a simple object).
update()	Executes INSERT, UPDATE, DELETE statements.
batchUpdate()	Executes batch updates.
execute()	Runs general SQL (e.g., DDL statements).

---

🔷 Basic Setup

✅ 1. Maven Dependency

xml
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.30</version>
</dependency>

---

✅ 2. Configuration Example

@Configuration
public class AppConfig {

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/mydb");
        ds.setUsername("root");
        ds.setPassword("password");
        return ds;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

---

🔷 Example Usage

✅ Insert Data

@Autowired
private JdbcTemplate jdbcTemplate;

public int saveEmployee(String name, double salary) {
    String sql = "INSERT INTO employee(name, salary) VALUES (?, ?)";
    return jdbcTemplate.update(sql, name, salary);
}

---

✅ Fetch Single Record

public Employee getEmployeeById(int id) {
    String sql = "SELECT * FROM employee WHERE id = ?";
    return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Employee.class), id);
}

---

✅ Fetch Multiple Records

public List<Employee> getAllEmployees() {
    String sql = "SELECT * FROM employee";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Employee.class));
}

---

✅ Custom RowMapper

public class EmployeeRowMapper implements RowMapper<Employee> {
    @Override
    public Employee mapRow(ResultSet rs, int rowNum) throws SQLException {
        Employee emp = new Employee();
        emp.setId(rs.getInt("id"));
        emp.setName(rs.getString("name"));
        emp.setSalary(rs.getDouble("salary"));
        return emp;
    }
}

public List<Employee> getEmployees() {
    String sql = "SELECT * FROM employee";
    return jdbcTemplate.query(sql, new EmployeeRowMapper());
}

---

🔷 Best Practices

• Use named parameters with NamedParameterJdbcTemplate for clarity.

• Avoid using * in queries — select explicit columns.

• Use RowMapper or BeanPropertyRowMapper for object mapping.

• Integrate with Spring Transaction management (@Transactional).

---

🔷 Real-World Use Case

@Repository
public class EmployeeRepository {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<Employee> findEmployeesByDept(String dept) {
        String sql = "SELECT * FROM employee WHERE department = ?";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Employee.class), dept);
    }

    public int updateSalary(int empId, double salary) {
        String sql = "UPDATE employee SET salary = ? WHERE id = ?";
        return jdbcTemplate.update(sql, salary, empId);
    }
}

2. HibernateTemplate  in Spring Framework
HibernateTemplate is a helper class provided by the Spring Framework (part of org.springframework.orm.hibernate5) that simplifies data access code using Hibernate. It follows the Template Method design pattern and handles repetitive boilerplate code such as opening/closing sessions, handling transactions, and translating exceptions.
It is typically used in Spring + Hibernate integration to simplify DAO (Data Access Object) operations.
🔷 Core Benefits of HibernateTemplate with Detailed Explanation and Examples
✅ 1. Simplifies Interactions with Hibernate Session
Hibernate operations like save, update, delete, and get require boilerplate code using Session, Transaction, and proper try-catch-finally blocks. HibernateTemplate encapsulates all that internally.
🔸 Example Without HibernateTemplate:
    Session session = sessionFactory.openSession();
    Transaction tx = null;
    try {
        tx = session.beginTransaction();
        session.save(emp);
        tx.commit();
    } catch (Exception e) {
        if (tx != null) tx.rollback();
        e.printStackTrace();
    } finally {
        session.close();
    }
}
🔸 Example With HibernateTemplate:
private HibernateTemplate hibernateTemplate;

public void saveEmployee(Employee emp) {
    hibernateTemplate.save(emp);
}
🔹 Benefit: Just one line replaces multiple lines of session, transaction, and exception-handling code.
✅ 2. Common Functions Are Simplified to Single Method Calls
HibernateTemplate provides convenient one-liner methods for common database operations.
🔸 Example: Load all Employees
✅ 3. Automatic Session Management
You don’t need to manually manage Session objects. It internally opens, flushes, and closes the session, so you avoid common mistakes like session leaks or forgetting to close.
✅ 4. Automatic Exception Translation
Hibernate throws checked exceptions like HibernateException. HibernateTemplate converts these into Spring’s runtime DataAccessException, which is part of a unified exception hierarchy in Spring.
This means:
No need to catch or declare checked exceptions.
Exception handling becomes easier and consistent across the DAO layer.
🔸 Example:
    hibernateTemplate.save(emp);
} catch (DataAccessException ex) {
    // Handle exception without worrying about checked HibernateException
}
✅ 5. Integration with Spring Transactions
HibernateTemplate works well with Spring’s @Transactional annotation. You can define transaction boundaries declaratively at the service layer.
🔸 Example:
public void updateEmployee(Employee emp) {
    hibernateTemplate.update(emp);
}
This ensures:
Automatic rollback on exceptions.
Commit if no exception is thrown.
✅ 6. Support for Callback Programming (HibernateCallback)
For complex queries or operations, you can pass a custom implementation of HibernateCallback to execute() method, gaining full access to Session object.
🔸 Example:
    session.createQuery("from Employee where salary > 50000", Employee.class).list()
);
🔹 Benefit: You still get session and exception management while using advanced features.
✅ 7. Clean and Readable DAO Code
By abstracting away boilerplate, HibernateTemplate allows you to write clean, concise, and maintainable DAO classes.
✅ Summary Table: Benefits of HibernateTemplate
⚠️ Note on Modern Usage
HibernateTemplate was widely used with Hibernate 3 and 4.
In modern Spring Boot applications, it's largely replaced by Spring Data JPA (JpaRepository), which offers even more abstraction.
However, HibernateTemplate is still relevant in legacy systems and for understanding underlying data access design patterns.
public void saveEmployee(Employee emp) {
@Autowired
Operation
HibernateTemplate Method
Save
save(Object entity)
Update
update(Object entity)
Delete
delete(Object entity)
Retrieve
get(Class, Serializable)
List All
loadAll(Class)
java

List<Employee> employees = hibernateTemplate.loadAll(Employee.class);
try {
@Transactional
java
List<Employee> result = hibernateTemplate.execute(session -> 
Benefit
Explanation
Simplified Hibernate interaction
One-liner for common operations like save, get, update
Automatic session management
No need to manually open/close sessions
Auto exception translation
Converts Hibernate exceptions to Spring's DataAccessException
Integrated with Spring AOP
Works with @Transactional
Callback support
Allows advanced queries with HibernateCallback
Encourages best practices
Cleaner, safer, and reusable code patterns  
🟩 3) MongoTemplate in Java (Spring Data MongoDB)

MongoTemplate is a core class in Spring Data MongoDB used to interact with MongoDB. It provides a powerful and flexible way to perform CRUD operations, aggregation, indexing, and more.

🔷 Why use MongoTemplate?

✅ Direct control over MongoDB queries

✅ Fine-grained operations (complex queries, custom conversions)

✅ Integrates with Spring’s dependency injection

✅ Supports aggregation framework

✅ Better for advanced use-cases than repository interfaces

🔷 Maven Dependency

Add this to your pom.xml:
xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>


🔷 Configuration

Spring Boot auto-configures MongoTemplate using application.properties:
properties

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=testdb

Or customize using a MongoClient bean:

@Configuration
public class MongoConfig {

    @Bean
    public MongoClient mongoClient() {
        return MongoClients.create("mongodb://localhost:27017");
    }

    @Bean
    public MongoTemplate mongoTemplate() {
        return new MongoTemplate(mongoClient(), "testdb");
    }
}


🔷 Entity Class Example
@Document(collection = "employees")
public class Employee {
    @Id
    private String id;
    private String name;
    private String department;
    private double salary;

    // Getters & setters
}


🔷 Basic Operations with MongoTemplate

Assume we autowire MongoTemplate:

@Autowired
private MongoTemplate mongoTemplate;

✅ Insert a Document
public void insertEmployee(Employee emp) {
    mongoTemplate.insert(emp);
}


✅ Find All Documents
public List<Employee> findAllEmployees() {
    return mongoTemplate.findAll(Employee.class);
}


✅ Find by Field
public List<Employee> findByDepartment(String dept) {
    Query query = new Query();
    query.addCriteria(Criteria.where("department").is(dept));
    return mongoTemplate.find(query, Employee.class);
}


✅ Find by ID
public Employee getById(String id) {
    return mongoTemplate.findById(id, Employee.class);
}


✅ Update Document
public void updateSalary(String id, double newSalary) {
    Query query = new Query(Criteria.where("id").is(id));
    Update update = new Update().set("salary", newSalary);
    mongoTemplate.updateFirst(query, update, Employee.class);
}


✅ Delete Document
public void deleteById(String id) {
    Query query = new Query(Criteria.where("id").is(id));
    mongoTemplate.remove(query, Employee.class);
}


✅ Aggregation Example
public List<Document> getAvgSalaryByDept() {
    Aggregation agg = Aggregation.newAggregation(
        Aggregation.group("department").avg("salary").as("avgSalary")
    );

    AggregationResults<Document> results = mongoTemplate.aggregate(agg, "employees", Document.class);
    return results.getMappedResults();
}


🔷 Summary of Key Classes

Class
Purpose
MongoTemplate
Main class for interacting with MongoDB
Query
Defines search conditions
Criteria
Defines field conditions (e.g., .where("field").is(value))
Update
Used for specifying update operations
Aggregation
Used to build MongoDB aggregation pipelines
@Document
Annotation to define MongoDB collection mapping
@Id
Marks the primary identifier of a document
🔷 When to Use MongoTemplate vs MongoRepository

Use Case
Tool
Simple CRUD
MongoRepository
Complex Queries
MongoTemplate
Aggregation Pipelines
MongoTemplate
Fine-grained control
MongoTemplate
                                  
📌 What is KafkaTemplate?

KafkaTemplate<K, V> is a helper class provided by Spring for Apache Kafka that is used to send messages to Kafka topics.

It wraps the native KafkaProducer and simplifies sending messages in a Spring Boot application.

✅ Key Features



Simplified message sending to Kafka topics.


Supports sending with keys, partitions, timestamps.


Supports both sync and async messaging.


Integrates with Spring configuration and Kafka properties.



🔧 Maven Dependency

xml
<!-- Add this to your pom.xml -->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>


⚙️ Kafka Producer Configuration (Java Config)

java
@Configuration
public class KafkaProducerConfig {

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return new DefaultKafkaProducerFactory<>(configProps);
    }

    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}


🧪 Example Usage
🔹 1. Simple send (no key)


java
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;

public void sendMessage(String message) {
    kafkaTemplate.send("my-topic", message);
}

🔹 2. Send with key

java
kafkaTemplate.send("my-topic", "user123", "User created");

🔹 3. Send with partition, timestamp

java
kafkaTemplate.send("my-topic", 0, System.currentTimeMillis(), "user123", "User update");

🔹 4. Send JSON (object)

Add dependency:
xml
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

Configure JsonSerializer:
java
configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
                JsonSerializer.class);

Send object:
java
@Autowired
KafkaTemplate<String, MyObject> kafkaTemplate;

kafkaTemplate.send("json-topic", new MyObject("id123", "data"));


⚠️ KafkaTemplate Common Methods

Method
Description
send(String topic, V data)
Sends data to topic
send(String topic, K key, V data)
Sends key and data to topic
send(Message<?> message)
Sends Spring Message with headers
flush()
Flushes producer buffer
executeInTransaction(ProducerCallback)
Send messages within Kafka transaction
setDefaultTopic(String topic)
Sets a default topic
📥 Controller Example

java
@RestController
@RequestMapping("/kafka")
public class KafkaController {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @PostMapping("/send")
    public ResponseEntity<String> send(@RequestParam String message) {
        kafkaTemplate.send("my-topic", message);
        return ResponseEntity.ok("Message sent to Kafka!");
    }
}


🔄 Send with Callback (Async)

java
ListenableFuture<SendResult<String, String>> future =
        kafkaTemplate.send("my-topic", "async message");

future.addCallback(
    result -> System.out.println("Sent: " + result.getRecordMetadata()),
    ex -> System.err.println("Failed: " + ex.getMessage())
);


✅ Summary

Feature
Description
Class
KafkaTemplate<K, V>
Purpose
Sends messages to Kafka topics
Use Cases
Logging, messaging, event sourcing, notifications
Alternative
Native KafkaProducer (low-level API)
Integration
Works with Spring Boot and @KafkaListener