How to return required parameters as json response from pojo class in spring boot?

what I am trying to do is,
If I take one pojo class like

@Entity
@Table(name = "property_table")
public class Property {
@Id
@Column(name = "property_id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int propertyId;
@Column(name = "property_name")
private String propertyName;
@Column(name = "property_type")
private String propertyType;
}

In RestController I wrote Two Methods like

   @GetMapping(value = "/getProperties", produces = { "application/json",
"application/xml" }, consumes = { "application/xml", "application/json" })
@ResponseBody
public List<Property> getProperties() {
//some code 
}
@GetMapping(value = "/getPropertyById", produces = { "application/json",
"application/xml" }, consumes = { "application/xml", "application/json" })
@ResponseBody
public Property getPropertyById() {
//some code 
}

So, hear what I am trying to do is
for first api method I want return json like some parameters from Property pojo class i.e., like

for getProperties api method

{
"property":[
{
"propertyId":001,
"propertyName":"PROPERTY 1"
},
{
"propertyId":002,
"propertyName":"PROPERTY 2"
}
],

In the Above json I want to return only two parameters i.e propertyId,propertyName and remaining parameter i.e propertyType I dont want to retun in json.

How to return like that?

and for the second api method I want to return all three parameters. i.e., like below

for getPropertyById api method

{
"propertyId":001,
"propertyName":"PROPERTY 1",
"propertyType:"PROPERTY_TYPE 1"
},

how to maintain different json response using same pojo class with different parameters for different api methods.
please help me to solve this isuue.
Thanks.

REST API under/over-fetching is a well-known problem. There's only two (classical ways) to handle that.

The first one is to build one model per each attribute visibility state. So, in your case, you'll need to create two different models (this kind of models are called DTO - Data Transfert Object). One model will have a propertyType attribute, the other will not. The model Property you've shared shows that you use the same class as entity and as transfert object. This solution will add some complexity to your app because you will have to implement some mappers to convert your entity to a corresponding DTO.

The second one is to accept that you send an attribute that will not be useful (be aware of the over-fetching). This solution is often the most adopted one. The cons of this solution is when you don't want to send something to your client (imagine a User model, you want to get the password from your client but you don't want to sent it back to it). Another obvious negative point is that the transactions will be larger but it is negligible in most cases

I would strongly advice you to keep your @Entity isolated in the 'db' layer. So that changes on the database side don't affect your API and vice versa. Also, you will have much better control over what data is exposed in your API. For your needs you can create 2 true DTOs, like PropertyDto and PropertyDetailsDto (or using private fields and getters/setters).

public class PropertyDto {
public String propertyId;
public String propertyName;
}
public class PropertyDetailsDto extends PropertyDto {
public String propertyType;
}

Map your @Entity to a specific dto corresponding to your needs.

EDIT

public List<PropertyDto> getProperties() {
return toPropertyDtos(repository.findAll());
}
public PropertyDetailsDto getPropertyById(Long id) {
return toPropertyDetailsDto(repository.findBy(id));
}
in some Mapper.java
...
public static List<PropertyDto> toPropertyDtos(List<Property> properties) {
return properties.stream()
.map(Mapper::toPropertyDto)
.collect(toList());
}
private static PropertyDto toPropertyDto(Property property) {
PropertyDto dto = new PropertyDto();
dto.propertyId = property.propertyId;
dto.propertyName = property.propertyName;
return dto;
}
// same stuff for `toPropertyDetailsDto`, you could extract common mapping parts in a separate private method inside `Mapper`

...