Implementing Dynamic Filtering for RESTful Services

In the previous section, we have performed static filtering. Now we are moving to dynamic filtering.

In the dynamic filtering, we define different filters for different services, according to need. So there exists the concept of dynamic filtering.

Suppose there are three fields: name, phone, and salary. We want to send two fields: name and salary for the first service and name and phone for the second service.

But there is a limitation in dynamic filtering. We cannot configure the dynamic filtering directly in the bean. We need to start configuring filtering, where we are retrieving the values. To implement dynamic filtering, we use a class named MappingJacksonValue. If we look at the class definition, we found the filter method definition there.

Let's see how to implement dynamic filtering in our project.

In the following example, we will send a name and salary for "/filtering" mapping.

Step 1: Open FilteringController.java file.

Step 2: Create a constructor of MappingJacksonValue class and pass a bean (someBean) as a constructor argument. We want to create a mapping Jackson value for this particular bean.

Step 3: To configure the filters, we need to create them. To create a filter, declare local variable filters of type FilterProvider. FilterProvider is an abstract class. It has a single implementation of the SingleFilterProvider method. Invoke the addFilter() method that has two parameters String id and SimpleBeanPropretyFilter filter.

FilterProvider filters=new SimpleFilterProvider().addFilter("SomeBeanFilter", filter);

Step 4: Invoke the static method filterOutAllExcept() of the class SimpleBeanPropertyFilter class. It filters all the fields in response except the fields which we have specified. We want to send the name and salary field in the response, so we have specified these two fields.

SimpleBeanPropertyFilter filter=SimpleBeanPropertyFilter.filterOutAllExcept("name", "salary");

Step 5: Configure the filters.

Step 6: Instead of returning the someBean return mapping.

Step 7: We have returned mapping, so we are required to change the return type of the method to MappingJacksonValue.

public MappingJacksonValue retrieveSomeBean()

@RequestMapping("/filtering")
public MappingJacksonValue retrieveSomeBean()
{
SomeBean someBean=new SomeBean("Amit", "9999999999","39000");
//invoking static method filterOutAllExcept()
SimpleBeanPropertyFilter filter=SimpleBeanPropertyFilter.filterOutAllExcept("name", "salary");
//creating filter using FilterProvider class
FilterProvider filters=new SimpleFilterProvider().addFilter("SomeBeanFilter",filter);
//constructor of MappingJacksonValue class  that has bean as constructor argument
MappingJacksonValue mapping = new MappingJacksonValue(someBean);
//configuring filters
mapping.setFilters(filters);
return mapping;
}

Remember: The list of valid filters should be defined in the bean. If we don't do that it will return all the fields.

Step 8: Open SomeBean.java file and define a filter by using the annotation @JsonFilter. It is used at class level. It defines a filter name which we filter out properties in JSON serialization.

SomeBean.java

package com.javatpoint.server.main.filtering;
import com.fasterxml.jackson.annotation.JsonFilter;
@JsonFilter("SomeBeanFilter")
public class SomeBean 
{
private  String name;
private  String phone;
//JsonIgnore indicates that the annotated method or field is to be ignored
//@JsonIgnore
private  String salary;
//generating constructor
public SomeBean(String name, String phone, String salary) 
{
super();	
this.name = name;
this.phone = phone;
this.salary = salary;
}
public String getName() 
{
return name;
}
public void setName(String name) 
{
this.name = name;
}
public String getPhone() 
{
return phone;
}
public void setPhone(String phone) 
{
this.phone = phone;
}
public String getSalary() 
{
return salary;
}
public void setSalary(String salary) 
{
this.salary = salary;
}
}

Let's implement the dynamic filtering in the second method. In this method we will return name and phone field for "/filtering-list" mapping.

Step 1: In this method, we first change the return type of the method to MappingJacksonValue.

Step 2: Create a list of SomeBean.

List<SomeBean> list=Arrays.asList(new SomeBean("Saurabh", "8888888888","20000"), new SomeBean("Devesh", "1111111111","34000"));

Step 3: Specify the field name which we want to send in the response. In our case, we have specified name and phone.

SimpleBeanPropertyFilter filter=SimpleBeanPropertyFilter.filterOutAllExcept("name", "phone");

Step 4: Pass the list in MappingJacksonValue constructor.

Step 5: Return mapping.

@RequestMapping("/filtering-list")
public MappingJacksonValue retrieveListOfSomeBeans()
{
List<SomeBean> list=Arrays.asList(new SomeBean("Saurabh", "8888888888","20000"), new SomeBean("Devesh", "1111111111","34000"));
//invoking static method filterOutAllExcept()
SimpleBeanPropertyFilter filter=SimpleBeanPropertyFilter.filterOutAllExcept("name", "phone");
FilterProvider filters=new SimpleFilterProvider().addFilter("SomeBeanFilter",filter);
//constructor of MappingJacksonValue class that has list as constructor argument
MappingJacksonValue mapping = new MappingJacksonValue(list);
//configuring filter
mapping.setFilters(filters);
return mapping;
}

FilteringController.java

package com.javatpoint.server.main.filtering;
import java.util.Arrays;
import java.util.List;
import org.springframework.http.converter.json.MappingJacksonValue;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.fasterxml.jackson.databind.ser.FilterProvider;
@RestController
public class FilteringController 
{
//returning a single bean as response
//values to send name and salary															
@RequestMapping("/filtering")
public MappingJacksonValue retrieveSomeBean()
{
SomeBean someBean=new SomeBean("Amit", "9999999999","39000");
//invoking static method filterOutAllExcept()
SimpleBeanPropertyFilter filter=SimpleBeanPropertyFilter.filterOutAllExcept("name", "salary");
//creating filter using FilterProvider class
FilterProvider filters=new SimpleFilterProvider().addFilter("SomeBeanFilter",filter);
//constructor of MappingJacksonValue class  that has bean as constructor argument
MappingJacksonValue mapping = new MappingJacksonValue(someBean);
//configuring filters
mapping.setFilters(filters);
return mapping;
}
//returning a list of SomeBeans as response
//values to send name and phone
@RequestMapping("/filtering-list")
public MappingJacksonValue retrieveListOfSomeBeans()
{
List<SomeBean> list=Arrays.asList(new SomeBean("Saurabh", "8888888888","20000"), new SomeBean("Devesh", "1111111111","34000"));
//invoking static method filterOutAllExcept()
SimpleBeanPropertyFilter filter=SimpleBeanPropertyFilter.filterOutAllExcept("name", "phone");
FilterProvider filters=new SimpleFilterProvider().addFilter("SomeBeanFilter",filter);
//constructor of MappingJacksonValue class that has list as constructor argument
MappingJacksonValue mapping = new MappingJacksonValue(list);
//configuring filter
mapping.setFilters(filters);
return mapping;
}
}

Now Open the REST Client Postman and send a GET request with the URI http://localhost:8080/filtering. It returns the two fields name and salary in the response as shown in the following image.

Implementing Dynamic Filtering for RESTful Services

Again, send a GET request with the URI http://localhost:8080/filtering-list. It returns a list with two fields name and phone in the response, as shown in the following image.