Forem: hairshkumar

If you're looking for a powerful search engine and data visualization tool, then you need to install Elasticsearch and Kibana. Elasticsearch is a distributed, Restful search and analytics engine that helps you find the right information quickly.

What is Kibana and where is it used?

Kibana is a data visualization tool that lets you see your data in creative and exciting ways. Having both of these tools installed can be extremely beneficial for anyone who wants to be able to quickly find and visualize their data.

Steps to download and install Elastic search and kibana Integrate ElasticSearch with kibana

Some of the term used in elastic search.

Index - similar to table which store record(document) in it.
Document - JSON object stored in index

Let create a index and insert documents into it.

Index creation and their settings in elastic searh

Insert documents into elastic index from Spring boot API

Fetching documents from index by building query

A Detailed post with examples are available in codebooker

Map Struct Tutorial - autogenerate mapper code in java

hairshkumar — Sun, 02 Oct 2022 07:07:43 +0000

Normal mapping

public class Mapper {

    public Employee toEmployee(EmployeeDTO dto) {

        Employee employee=new Employee();

        employee.setName(dto.getName());
        employee.setJobTitle(dto.getJobTitle());
        employee.setJoinedDate(dto.getJoinedDate());
        employee.setMobileNo(dto.getMobileNo());
        employee.setDepartment(dto.getDepartment());
        employee.setSalary(dto.getSalary());

        return employee;

    }
}

what is mapstruck?

MapStruct is a code generator that greatly simplifies the implementation of mappings between Java models and DTO. Using Mapstruck we don’t have to long mapper code instead simply we need to say source and destination class.

MapStruck automatically generates mapper code which maps fields based on name from source to destination class also we can pass custom mapping for field.

mapstruck maven dependency

<org.mapstruct.version>1.5.2.Final</org.mapstruct.version>

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>${org.mapstruct.version}</version>
</dependency>

if you are using Lombok to reduce boilerplate cod in entity or DTO class then add below in pom.xml

How to create a Mapper in mapstruck?

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${org.projectlombok.version}</version>
                        </path>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${org.mapstruct.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </build>

Create an interface and annotate with @Mapper. Now let's define a method. The method parameter acts as source and method return type acts as Target. MapStruck will map source fields to target fields if they have the same field name.

Mapping fields with same name

By default, MapStruck maps fields by name if source and target have fields with same name then mapper maps the field. The EmployeeDTO and Employee both classes have the same property names.

@Mapper(componentModel = "spring")
public interface EmployeeMapper {

    Employee toEmployee(EmployeeDTO employeeDTO);

}

The componentModel = “spring” define this mapper as spring bean which we can autowire in our application.

The generated class code will look like below the source and target classes both having the same property names.

@Component
public class EmployeeMapperImpl implements EmployeeMapper {

    @Override
    public Employee toEmployee(EmployeeDTO employeeDTO) {
        if ( employeeDTO == null ) {
            return null;
        }

        Employee employee = new Employee();

        employee.setDepartment( employeeDTO.getDepartment() );
        employee.setGender( employeeDTO.getGender() );
        employee.setId( employeeDTO.getId() );
        employee.setJobTitle( employeeDTO.getJobTitle() );
        employee.setJoinedDate( employeeDTO.getJoinedDate() );
        employee.setMobileNo( employeeDTO.getMobileNo() );
        employee.setName( employeeDTO.getName() );
        employee.setSalary( employeeDTO.getSalary() );

        return employee;
    }
}

Mapping fields with different name

In most of the cases, the source and target classes will not have same field names so now how to map these fields for this we have @Mapping annotation which take the target field name and soruce field name map these field. We can give custom mapping logic for fields in @Mapping annotation.

@Mappings takes group of @Mapping annotation if there is more mapping logic than its better give them inside @Mappings.

public interface EmployeeMapper {

    @Mappings({
        @Mapping(target = "jobTitle", source = "title"),
        @Mapping(target = "joinedDate", source = "startingdate")
    })
    Employee toEmployee(EmployeeDTO employeeDTO);

}

Mapping nested beans fields

Here we will see how we can map nested object fields if you see example below the Employee class has Personal object which has name, gender, age and Address object.

We have to give full path to the field example personal.address.streetaddress in target, so mapper will search for streetaddress inside address in personal object.

@Mappings({ 
    @Mapping(target = "personal.name", source = "firstName"),
    @Mapping(target = "personal.gender", source = "gender"), 
    @Mapping(target = "personal.age", source = "age"),
    @Mapping(target = "personal.address.streetaddress", source = "dto.primaryAddr.line1"),
    @Mapping(target = "personal.address.city", source = "dto.primaryAddr.city"),
    @Mapping(target = "personal.address.postalcode", source = "dto.primaryAddr.postalCode") 
})
Employee toEmployee(EmployeeDTO dto);

Mapping custom method

In some cases it can be required to manually implement a specific mapping from one type to another which can’t be generated by MapStruct. One way to handle this is to implement the custom method on another class which then is used by mappers generated by MapStruct

Define java 8 default method in the interface and provide the implementation. We use @Named to name the method.

In the @Mapping define the source and target, give the @Named method name in the qualifiedByName attributes so the mapstruck will generate the code and call the default method

package com.example.graphql.mapstruck;

import java.util.ArrayList;
import java.util.List;

@Mapper(componentModel = "spring")
public interface EmployeeMapper {

    @Mapping(target="primaryAddr",source ="personal.address",qualifiedByName = "addressdto" )
    EmployeeDTO toEmployeeDto(Employee employee);

    @Named("addressdto")
    default PrimaryAddr composeAddress(Address address) {

        PrimaryAddr primaryAddr=new PrimaryAddr();

        primaryAddr.setLine1(address.getStreetaddress());
        primaryAddr.setCity(address.getCity());
        primaryAddr.setPostalCode(address.getPostalcode());

        return primaryAddr;

    }

}

Let see how mapstruck have generated the mapper code for the above custom method.The generated mapper code internally call our custom method for mapping address.

public class EmployeeMapperImpl implements EmployeeMapper {

    @Override
    public EmployeeDTO toEmployeeDto(Employee employee) {
        if ( employee == null ) {
            return null;
        }

        EmployeeDTO employeeDTO = new EmployeeDTO();

        employeeDTO.setPrimaryAddr( composeAddress( employeePersonalAddress( employee ) ) );

        return employeeDTO;
    }

    private Address employeePersonalAddress(Employee employee) {
        if ( employee == null ) {
            return null;
        }
        Personal personal = employee.getPersonal();
        if ( personal == null ) {
            return null;
        }
        Address address = personal.getAddress();
        if ( address == null ) {
            return null;
        }
        return address;
    }
}

Integrating GraphQL in Spring boot Project guideline

hairshkumar — Tue, 11 Jan 2022 08:15:28 +0000

In this blog, we will learn graphql API in spring boot and see graphql schema, query, etc.

we are going to implement graphql in the existing spring boot project that we have created in the previous blog spring-boot-JPA-integration-with-SQLite.

GraphQL API tutorial in Spring boot

What is GraphQL?

GraphQL is a query language for API not specific to any database or framework developed by Facebook, GraphQL client uses graphQL query( specific which fields we are looking for in response) to fetch data from the server.

In GraphQL, the client can get all details in a single request instead of multiple calls to the backend like REST API.

Graphql Maven dependency

we need to add the below dependency in the pom.xml file which provides support for creating graphQL API in spring boot.

<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphql-spring-boot-starter</artifactId>
    <version>5.0.2</version>
</dependency>
<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphql-java-tools</artifactId>
    <version>5.2.4</version>
</dependency>
<!-- GraphiQL -->
<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphiql-spring-boot-starter</artifactId>
    <version>5.0.2</version>
</dependency>

By default, the GraphQL Service will be accessible on /graphql URL and will accept POST requests with the GraphQL Payload. If required, you can modify this endpoint in our application.properties file.

Create GraphQl Schema

First, we need to create a graphql schema that contains the graphql query and object type (similar to class) that return in the response.

graphQL API tutorial schema diagram

The graphql server exposes this schema to the graphql client describing the available query and structure of object data (class and their field) based on schema the client creates a query and sends it to the server for execution.

create a schema.graphqls file inside the src/main/resource folder.

schema {
  query: Query
}

type Query {
  getAllEmployee: [Employee]
  getEmployeeById(id: Int): Employee
}

type Employee {
  id: ID
  name: String
  jobTitle: String
  mobileNo: String
  joinedDate: String
  gender: String
  department: Department
  project: Project
}

type Department {
  id: ID
  name: String
}

type Project {
  id: ID
  name: String
}

Here the Employee, Department, and Project are graphql object types. The [Employee] means an array of employee objects.

The getAllEmployee and getEmployeeById are queries the client use to fetch object data from the graphql server.

we can have several separate schema files to organize the schemes, e.g. we can have employee.graphqls, project.graphqls, etc.

There can be only one query and mutation type describing all operations, if there are separate schema files each containing its own query and mutation then use extend keyword so all queries and mutation are added together.

Create JPA repository

let's create a JPA repository to get employee details from the SQLite database.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.graphql.model.Employee;

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Integer> {

}

Create Query Resolver

Now create a class GraphQLService that implements GraphQLQueryResolver, this class contains the actual implementation of a query defined in the graphql schema.

The query name defined in schema and method name must be the same.

Please see the complete post here