Access SAP HANA in the NEO environment

In the first part of the blog series I introduced you to Java development based on the Spring framework. Using a simple RestController the basics were shown.

What would an application be without access to a database. In the SAP Cloud context it is obvious that SAP HANA is used as database. In this part of the blog series I show you how to access the database in the NEO environment.

JNDI – The yellow pages

The HANA database is accessed via JNDI, in my opinion one of the most exciting technologies in the Java environment. With a JNDI lookup resources managed by the runtime environment can be loaded. The idea behind it is very simple – the runtime environment takes care of instantiating the required classes and makes them available to the application.

In order for the application presented here to support JNDI, some activities must be carried out. In the first step it is necessary to create a subdirectory called webapp in the directory src > main and in this subdirectory a subdirectory called WEB-INF. In the directory src > main > webapp > WEB-INF it is only necessary to create a file named web.xml.


Folderstructure für web.xml

Those resources that are managed by JNDI must be listed in the web.xml file as resource reference (resource-ref). The name (res-ref-name) under which the resource is addressed and the underlying Java class (res-type) must be defined.


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns=""

Declare Spring Data Dependency

The first step has already been completed. Since we do not implement the access to the database with SQL commands ourselves, but use Spring Data, we have to define a corresponding dependency in pom.xml.


Since Spring Data supports a variety of databases, it is necessary to tell the runtime environment which database to use. This is done using the file. If this file does not yet exist, it must be created in the directory src > main > resources. The fully qualified class name of the HANA driver is = org.hibernate.dialect.HANAColumnStoreDialect = 10


Spring @Configuration annotation is part of the Spring Core Framework. The Spring annotation indicates that the class has @Bean definition methods. This allows the Spring container to process the class and generate Spring Beans at runtime that can be used in the application.

For use in the Neo Stack, the data source must be loaded using JNDI. A corresponding class must be created for this. The following code snippet shows the complete class.

Neo Datasource Configuration

package at.clouddna.demo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.lookup.JndiDataSourceLookup;
import javax.sql.DataSource;
import java.sql.SQLException;
public class NeoConfig 
	public DataSource jndiDataSource() throws IllegalArgumentException, SQLException
		JndiDataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
		DataSource ds = dataSourceLookup.getDataSource("java:comp/env/jdbc/DefaultDB");
		return ds;
The JNDI lookup aims at the name java:comp/env/jdbc/DefaultDB. The prefix java:comp/env/ is always the same in the SAP Cloud Platform. The name jdbc/DefaultDB defined behind it corresponds to the res-ref-name in the web.xml

Development of an entity class

The use of Spring-Data allows a very efficient development of the persistence layer. Spring-Data is based on the Hibernate Framework. As soon as we create a class and assign the annotation @Entity to it, a corresponding table is created in the underlying database. In the following code snippet I show you a simple user class.

package at.clouddna.demo.model;
import javax.persistence.*;
public class User {
    @Column(nullable = false)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    protected Long id;
    private String firstname;
    private String lastname;
    public Long getId() {
    public void setId(Long id) { = id;
    public void setFirstname(String firstname) {
        this.firstname = firstname;
    public String getFirstname() {
        return this.firstname;
    public void setLastname(String lastname) {
        this.lastname = lastname;
    public String getLastname() {
        return this.lastname;

CRUD Methods

The great thing about Spring-Data is the out-of-the-box availability of CRUD methods. All you have to do is create an interface that inherits from the JpaRespository. This is shown for the user entity in the following code snippet.

package at.clouddna.demo.repository;
import at.clouddna.demo.model.User;
public interface IUserRepository extends JpaRepository<User, Long> {
The repository can now be used directly in the controller by accessing it via autowiring. However, my company refrains from this. We always create an associated DTO (Data Transfer Object) for each entity class and additionally create a service class that is provided with the @Service Annotation, which encapsulates the use of the repository. The service class can be injected in the controller via the @Autowired Annotation.

Of course I will show you how it works.

ServiceBase Classs and Model Mapper

The mapping of the Entity class to the DTO and vice versa is not done manually but with ModelMapper. The modelmapper must be included in pom.xml as a dependency.


package at.clouddna.codegenerator.service.da;
import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;
import java.util.Collection;
import java.util.List;
public abstract class ServiceBase {
 private ModelMapper modelMapper;
 public ServiceBase(){
 this.modelMapper = new ModelMapper();
 public <D, T> D map(T entity, Class<D> outClass) {
 return, outClass);
 public <D, T> List<D> mapAll(Collection<T> entityList, Class<D> outCLass) {
 .map(entity -> map(entity, outCLass))
 protected void writeToFile(String fileName, String content) throws IOException {
 FileOutputStream outputStream = new FileOutputStream(fileName);
 byte[] strToBytes = content.getBytes();
 protected void writeToFile(String fileName, byte[] content) throws IOException {
 FileOutputStream outputStream = new FileOutputStream(fileName);

Service Class

The Service class inherits from the ServiceBase class and encapsulates access to the database. The following code snippet shows the UserService class. It is important that the class is provided with the annotation @Service. This allows it to be used in the controller via autowiring.

package at.clouddna.demo.service;
import at.clouddna.demo.dto.UserDto;
import at.clouddna.demo.model.User;
import at.clouddna.demo.respository.IUserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
public class UserService extends ServiceBase {
 private IUserRepository repository;
 public UserDto create(UserDto userDto) {
 return map(, User.class)), UserDto.class);
 public UserDto update(UserDto userDto) {
 return map(, User.class)), UserDto.class);
 public boolean delete(Long id) {
 return true;
 public UserDto findById(Long id) {
 Optional<User> userOptional = repository.findById(id);
 if(!userOptional.isPresent()) {
 return null;
 return map(userOptional.get(), UserDto.class);
 public List<UserDto> findAll() {
 return mapAll(repository.findAll(), UserDto.class);


Finally, I will show you how the previously developed service in the RestController can be fully used for all CRUD methods. You will be surprised how easy it is!

package at.clouddna.demo.controller;
import at.clouddna.demo.dto.UserDto;
import at.clouddna.demo.model.User;
import at.clouddna.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
public class UserController {
 private UserService userService;
 public ResponseEntity getAll() {
 return ResponseEntity.ok(userService.findAll());
 public ResponseEntity getById(@PathVariable("id") Long id) {
 return ResponseEntity.ok(userService.findById(id));
 public ResponseEntity create(@RequestBody UserDto body) {
 return ResponseEntity.ok(userService.create(body));
 public ResponseEntity update(@PathVariable("id") Long id,
 @RequestBody UserDto body) {
 return ResponseEntity.ok(userService.update(body));
 public ResponseEntity delete(@PathVariable("id") Long id) {
 return ResponseEntity.ok(userService.delete(id));


I hope that in this part I have made Java development in the SAP Cloud Platform appealing to you. As you have hopefully realized, this is not witchcraft and not space science. I would like to give you one more tip – already during the planning of the project, make sure that everything is clearly structured and that you define your own package for entity, DTO, repository, service and controller.