DEV Community: Raja

Palmyra-FlexiQuery

Raja — Thu, 13 Feb 2025 18:24:50 +0000

An alternative to CriteriaBuilders for SpringBoot/JPA developers.

As part of our roadmap on SpringBoot integration, we are introducing Flexi Query feature into Standard Springboot Controller.
Now you can query N number of tables with criteria and order by -- all driven by Annotations.

Sample project here -- https://github.com/palmyralabs/springboot-query

@RestController
@RequiredArgsConstructor
@RequestMapping("supplier")
public class SupplierController {
    private final ModelQueryService queryService;

    @GetMapping("")
    public void querySuppliers(@RequestParam Map<String, String> paramsMap) {
        RequestParams params = queryService.getRequestParams(SupplierModel.class, 
                paramsMap);     
        queryService.executeAndSendListResponse(params);
    }
}

@PalmyraType(type = "Supplier")
public class SupplierModel {
    private Integer id;
    private String name;
    private String email;
    private String phoneNumber;
    private String address;
}

The above model is a simple example show-casing to query single table. More examples on multi-table model will be posted soon.

Annotation/Handler driven REST API

Raja — Sat, 14 Oct 2023 15:27:52 +0000

Just a few lines of Annotation, would provide full fledged SQL Query Capabilities for your spring boot application..
Query capabilities to include - filter, order on any field (or limited fields) and pagination.

Would you like to explore / validate the palmyra framework and influence the development.. please let us know in the comments.

Simplifying CRUD Operations with Generics: Abstract CRUD Service

Raja — Thu, 15 Jun 2023 00:46:58 +0000

Let us explore how the intelligent use of generics can help us avoid writing repetitive boilerplate code. We'll demonstrate this by creating an abstract CRUD (Create, Read, Update, Delete) service that allows developers to enhance their productivity and concentrate more on the essential business logic. Let's get started!

Step 1: Understanding the Problem
When developing software, it's common to encounter repetitive code patterns, particularly when implementing CRUD operations. These operations often involve similar structures and functionalities that can be generalized. To address this issue, we can leverage the power of generics to create an abstract CRUD service that eliminates the need for redundant code.

This helps us to write a simplified service class to focus on business logic only. example as below..


@Service
@RequiredArgsConstructor
public class MyService extends AbstractCrudService<Employee, EmployeeEntity, Integer>{
    private final EmployeeRepository employeeRepository;
    @Override
    protected JpaRepository<EmployeeEntity, Integer> getJpaRepository() {
        return employeeRepository;
    }

    @Override
    protected Optional<EmployeeEntity> findUnique(Employee model) {
        return employeeRepository.findByRegistrationNumber(model.getRegistrationNumber());
    }

    @Override
    public Employee preCreate(Employee model) {
        // Generate and assign registration number here
        model.setRegistrationNumber(generate(16));
        return model;
    }
}

How to achieve this?

let us define an abstract class with the following properties and initialization. This is required to determine the model and entity classes in the runtime.

@Service
public abstract class AbstractCrudService<Model, Entity, ID> implements CrudService<Model, Entity, ID>, 
        CrudExtnService<Model, Entity, ID>{

    @Autowired
    private ModelMapper modelMapper;
    private Class<Model> modelClass;
    private Class<Entity> entityClass;

    @SuppressWarnings({ "unchecked", "rawtypes" })
    public AbstractCrudService() {
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        Type[] typeArgs = type.getActualTypeArguments();

        this.modelClass = ((Class) typeArgs[0]);
        this.entityClass = ((Class) typeArgs[1]);
    }

now let us define some abstract methods that must be implemented by the services. this is required get the jparepository and finding the unique records.

    protected abstract JpaRepository<Entity, ID> getJpaRepository();

    protected abstract Optional<Entity> findUnique(Model model);

the below generic methods would provide All the CRUD operations..

    @Override
    public List<Model> findAll() {
        return getJpaRepository().findAll().stream().map(e -> onList(toDto(e), e)).toList();
    }

    @Override
    public Optional<Model> getById(ID id) {
        return toDto(getJpaRepository().findById(id));
    }

    @Override
    public Model save(Model model) {
        Optional<Entity> dbInstance = findUnique(model);
        if (dbInstance.isPresent()) {
            return update(model, dbInstance.get());
        } else {
            return create(model);
        }
    }

    @Override
    public void delete(ID id) {
        getJpaRepository().deleteById(id);
    }

    private Optional<Model> toDto(Optional<Entity> entity) {
        if (entity.isPresent()) {
            Entity e = entity.get();
            return Optional.of(onGet(modelMapper.map(e, getModelClass()), e));
        } else
            return Optional.empty();
    }

    private Model toDto(Entity entity) {
        return modelMapper.map(entity, getModelClass());
    }

    private Model create(Model model) {
        model = preCreate(model);
        Entity entity = modelMapper.map(model, getEntityClass());
        getJpaRepository().save(entity);
        return postCreate(toDto(entity), entity);
    }

    private Model update(Model model, Entity entity) {
        model = preUpdate(model);
        modelMapper.map(model, entity);
        getJpaRepository().save(entity);
        return postUpdate(toDto(entity), entity);
    }

you can define an interface with the default methods (as hooks) of preUpdate, preCreate methods etc and use this methods to perform custom operations before saving, querying the data etc.,

By following this tutorial, you've learned how to harness the power of generics to create an abstract CRUD service. This approach allows you to eliminate repetitive boilerplate code and focus more on implementing the core business logic of your application. As a result, your development process becomes more efficient and maintainable. Experiment with generics in your future projects and unlock the potential for increased productivity!

Generics and Functional Interfaces - A practical example

Raja — Wed, 24 May 2023 06:29:02 +0000

Problem Statement:

On an multi-threaded environment a record shall be created in the database by one thread and another thread may be interested to fetch the record. Due to the multi threading nature, the second thread may need to wait or retry couple of times before getting hold of the record.
After performing an action in remoete web service, we might need to poll the service for the updated status. (though this is inefficient than using the message or event based communication).

Both of the above problem statements have a common theme of "getting the latest data by polling". A simple implementation would be put an for loop for the number of retries to fetch the data. if the data is fetched, the value is immediately returned.

@SneakyThrows
public Optional<Employee> getRecord(Long id){
   for(int i=0; i< 10; i++){
      Optional<Employee> emp = employeeRepository.findById(id);
      if(emp.isPresent()) return emp;
      Thread.sleep(200)
   }
   return Optional.empty();
}

Let us consider the scenario, where we would need to write the similar code block to retrieve the data from an external web serivces, a similar implementation needs to be written as well.

The above-retry logic can be implemented using Generics and functional interfaces as below.

Generic function

public class Utils{
 @SneakyThrows
    public static <T> Optional<T> getWithRetry( Supplier<Optional<T>> supplier, int retry){
        for(int i=0; i < retry; i++){
            Optional<T> data = supplier.get();
            if(data.isPresent())
                return data;
            Thread.sleep(200);
        }
        return Optional.empty();
    }
}

Invoking the function

public Optional<Employee> getRecord(Long id){
   return Utils.getWithRetry(
        () -> employeeRepository.findById(id)
        , 10);
}

Other data fetching functions can be defined as Supplier interfaces or lambda expressions and invoked using the 'getWithRetry' function. By implementing the Generic function, the retry logic can be reused across as needed.