Как создать универсальный DTO для парсинга JSON в методе PATCH?

Пытаюсь составить универсальный DTO для метода PATCH, но весь JSON записывается в поле key:

Объект Entity:

@Entity
@Table(name = "employee")
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
public class Employee {

    @Id
    @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="employee_seq")
    @SequenceGenerator(name="employee_seq", sequenceName="employee_seq", allocationSize=1)
    private Integer id;

    @Nonnull
    private String name;

    @Nonnull
    private String position;

    @Nonnull
    private Integer department;

    @Nonnull
    private Long phone;


    private String address;

    @Nonnull
    private String employmentDate;

}

DTO:

@Data
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class PatchDTO <T> {

    private String key;
    private T value;
}

Контроллер:

@RestController
public class EmployeeController{

    @Autowired
    EmployeeServiceImpl employeeService;

    EmployeeMapper mapper;


    @PatchMapping("/employee/{id}/update/{parameter}")
    public <T> HttpStatus updateEmployee(@PathVariable(value = "id") Integer employeeId,
                                         @PathVariable(value = "parameter") String parameter,
                                         @RequestBody Map<String, T> jsonData) throws
            EmployeeNotFoundException, ParseException{
        return employeeService.updateEmployee(employeeId, jsonData);
    }


}

Сервис:

@Service
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    @Autowired
    private DepartmentServiceImpl departmentService;

    @Autowired
    private PositionServiceImpl positionService;

    @Autowired
    private EmployeeMapperImpl employeeMapperImpl;

    public <T> HttpStatus updateEmployee(Integer employeeId, Map<String, T> jsonData) throws
            EmployeeNotFoundException, ParseException{

        Employee employee = (Employee) employeeRepository.findById(employeeId)
                .orElseThrow(() -> new EmployeeNotFoundException(employeeId));

        System.out.println(1234567890);

        PatchDTO patchDTO = employeeMapperImpl.toPatchDTO(jsonData);


        System.out.println("error is here");

        if (patchDTO.getKey().equals("name")) {
            employee.setName(patchDTO.getValue().toString());
        }

        employeeRepository.save(employee);
        return HttpStatus.OK;
    }
}

Мапперы:

@Component
public interface EmployeeMapper {

    EmployeeDTO toEmployeeDTO(Employee employee);

    Employee toEmployee(EmployeeDTO employeeDTO);

    <T> PatchDTO toPatchDTO(Map<String, T> dataToUpdate);

}

@Component
public class EmployeeMapperImpl implements EmployeeMapper {

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

        EmployeeDTO employeeDTO = new EmployeeDTO();

        employeeDTO.setId( employee.getId() );
        employeeDTO.setName( employee.getName() );
        employeeDTO.setPosition( employee.getPosition() );
        employeeDTO.setDepartment( employee.getDepartment() );
        employeeDTO.setPhone( employee.getPhone() );
        employeeDTO.setAddress( employee.getAddress() );
        employeeDTO.setEmploymentDate( employee.getEmploymentDate() );

        return employeeDTO;
    }

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

        Employee employee = new Employee();

        employee.setId( employeeDTO.getId() );
        employee.setName( employeeDTO.getName() );
        employee.setPosition( employeeDTO.getPosition() );
        employee.setDepartment( employeeDTO.getDepartment() );
        employee.setPhone( employeeDTO.getPhone() );
        employee.setAddress( employeeDTO.getAddress() );
        employee.setEmploymentDate( employeeDTO.getEmploymentDate() );

        return employee;
    }

    @Override
    public <T> PatchDTO toPatchDTO(Map<String, T> dataToUpdate) {
        if ( dataToUpdate == null ) {
            return null;
        }

        PatchDTO patchDTO = new PatchDTO();
        patchDTO.setKey(new ArrayList<String>(dataToUpdate.keySet()).get(0));
        patchDTO.setValue(new ArrayList<T>(dataToUpdate.values()).get(0));

        return patchDTO;
    }
}

Проблема в том, что метод setKey() в последнем маппере устанавливает сам передаваемый JSON, а не только его ключ.