I want to do some DB related actions in service method. Initialy it looks like this:

```
@Override
@Transactional
public void addDirectory(Directory directory) {
    //some cheks here
    directoryRepo.save(directory);
    rsdhUtilsService.createPhysTable(directory);
}

```

Firs method `directoryRepo.save(directory);` is just simple JPA save action, second one `rsdhUtilsService.createPhysTable(directory);` is `JDBCTemplate` stored procedure call from it's own service. The problem is: if any exceptions accures within JPA or SimpleJdbcCall action, transaction will rollback and nothig related to JPA won't be persited, but if exception occures **only** within JPA action, result of SimpleJdbcCall won't be affected by transaction rollback.
To illustrate this behaviour I've remove JAP action, mark `@Transactional` as `(readOnly = true)` and moved all `JDBCTemplate` related logic from another service to current one.

```
@Service
public class DirectoriesServiceImpl implements DirectoriesService {

    private final DirectoryRepo directoryRepo;

    private final MapSQLParamUtils sqlParamUtils;

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public DirectoriesServiceImpl(DirectoryRepo directoryRepo, MapSQLParamUtils sqlParamUtils, JdbcTemplate jdbcTemplate) {
        this.directoryRepo = directoryRepo;
        this.sqlParamUtils = sqlParamUtils;
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    @Transactional(readOnly = true)
    public void addDirectory(Directory directory) {
        directoryRepo.save(directory);

        new SimpleJdbcCall(jdbcTemplate).withSchemaName("RSDH_DICT").withCatalogName("UTL_DICT")
                .withFunctionName("create_dict")
                .executeFunction(String.class, sqlParamUtils.getMapSqlParamForCreatePhysTable(directory));
    }

}

```

As a result `@Transactional` annotation is ignored and I can see new records persisted in DB.
I've got only one DataSource configured via `application.properties`, and here is how `JDBCTemlate` configured

```
@Component
class MapSQLParamUtils {

    private final DataSource dataSource;

    @Autowired
    MapSQLParamUtils(DataSource dataSource) {
        this.dataSource = dataSource;
    }

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

}

```

So my questions are: why do `@Transactional` ignored by `SimpleJdbcCall` and how to configure `JPA` and `JDBCTemlate` to use same transaction manager.

**UPDATE**:
This is how I use this service in controller

```
@RestController
@RequestMapping(value = "/api/v1/directories")
public class DirectoriesRESTControllerV1 {

    private final DirectoriesService directoriesService;

    @Autowired
    public DirectoriesRESTControllerV1(DirectoriesService directoriesService) {
        this.directoriesService = directoriesService;
    }

    @PostMapping
    @PreAuthorize("hasPermission('DIRECTORIES_USER', 'W')")
    public ResponseEntity createDirectory(@NotNull @RequestBody DirectoryRequestDTO createDirectoryRequestDTO) {
        Directory directoryFromRequest = ServiceUtils.convertDtoToEntity(createDirectoryRequestDTO);
        directoriesService.addDirectory(directoryFromRequest);
        return ResponseEntity.noContent().build();
    }

}

```