Spring boot different in hibernate vs eclipselink - spring

Question

I'm trying to change from Hibernate to Eclipselink as Jpa provider for spring boot. However, I'm seeing some difference in behaviour between the two.
Eclipselink Configuration
package com.test.test2;
import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.vendor.AbstractJpaVendorAdapter;
import org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter;
import org.springframework.transaction.jta.JtaTransactionManager;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
#Configuration
public class EclipselinkJpaConfiguration extends JpaBaseConfiguration {
protected EclipselinkJpaConfiguration(DataSource dataSource, JpaProperties
properties, ObjectProvider<JtaTransactionManager> jtaTransactionManager) {
super(dataSource, properties, jtaTransactionManager);
}
#Override
protected AbstractJpaVendorAdapter createJpaVendorAdapter() {
return new EclipseLinkJpaVendorAdapter();
}
#Override
protected Map<String, Object> getVendorProperties() {
Map<String, Object> map = new HashMap<String, Object>();
map.put(PersistenceUnitProperties.WEAVING, "false");
return map;
}
}
Controller
package com.test.test2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
#RestController
public class PersonController {
#Autowired
PersonService personService;
#GetMapping("/test")
public ResponseEntity<String> test() {
return new ResponseEntity<String>(personService.helloWorld(), HttpStatus.OK);
}
#PostMapping("/createNewPerson")
public ResponseEntity<Person> createNewPerson() {
Person res = personService.createNewPerson();
return new ResponseEntity<Person>(res, HttpStatus.OK);
}
#PostMapping("/updatePerson/{id}")
public ResponseEntity<Person> updatePerson(#PathVariable("id") Long id) {
Person res = personService.updatePerson(id);
personService.transAnnotation();
return new ResponseEntity<Person>(res, HttpStatus.OK);
}
}
Service
package com.test.test2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
#Service
public class PersonService {
#Autowired
PersonRepository personRepository;
public String helloWorld() {
return "Hello World!";
}
public Person createNewPerson () {
Person newPerson = new Person();
newPerson.setFirstName("firstName");
newPerson.setLastName("lastName");
return personRepository.save(newPerson);
}
public Person updatePerson(Long id) {
Optional<Person> personOP = personRepository.findById(id);
if (personOP.isPresent()) {
Person person = personOP.get();
person.setFirstName("Update Name");
}
return null;
}
#Transactional(readOnly = true)
public void transAnnotation () {
}
}
Repository
package com.test.test2;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
#Repository
public interface PersonRepository extends JpaRepository<Person, Long>{
}
Eclipselink behavior
When calling /updatePerson/{id} api, person.firstName is updated to db without calling personRepoitory.save() if the next method is tagged with #Transactional.
As spring repository itself is transactional, even calling a personRepository.findAll() will commit and firstName is updated to db.
Logs
2021-11-24 12:01:06.264 INFO 2868 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8081 (http) with context path ''
2021-11-24 12:01:06.269 INFO 2868 --- [ main] com.test.test2.Test2Application : Started Test2Application in 1.966 seconds (JVM running for 2.227)
2021-11-24 12:01:12.689 INFO 2868 --- [nio-8081-exec-2] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-11-24 12:01:12.689 INFO 2868 --- [nio-8081-exec-2] o.s.web.servlet.DispatcherServlet : Initializing Servlet 'dispatcherServlet'
2021-11-24 12:01:12.689 INFO 2868 --- [nio-8081-exec-2] o.s.web.servlet.DispatcherServlet : Completed initialization in 0 ms
[EL Fine]: sql: 2021-11-24 12:01:12.741--ServerSession(2122837918)--Connection(555991754)--SELECT ID, first_name, last_name FROM TBL_PERSON WHERE (ID = ?)
bind => [1]
[EL Fine]: sql: 2021-11-24 12:01:12.771--ClientSession(1084235622)--Connection(819605412)--UPDATE TBL_PERSON SET first_name = ? WHERE (ID = ?)
bind => [Update Name, 1]
Whereas for Hibernate, the changes are not commited to db unless a save() is called.
I am aware that a if a function is tagged with #Transactional, we do not need to call save() as it will auto commit the changes. However, currently it is tagged only in the next method called.
Any possible causes for this? Could it be due to incorrect configuration?