Возвращаемые объекты в Rest API с Spring

Создание спокойного api для веб-приложения весной довольно просто. Предположим, у нас есть объект Movie, с именем, годом, списком жанров и списком актеров. Чтобы вернуть список всех фильмов в формате json, мы просто создаем метод в каком-то controllerе, который будет запрашивать базу данных и возвращать список как тело ResponseEntity. Весна волшебным образом сериализует его, и все отлично работает 🙂

Но что, если я в каком-то случае хочу, чтобы этот список актеров в фильме был сериализован, а не в другом? И в каком-то другом случае, наряду с полями classа фильма, мне нужно добавить некоторые другие свойства для каждого фильма в списке, какие значения динамически генерируются?

Моим текущим решением является использование @JsonIgnore в некоторых полях или создание classа MovieResponse с полями, такими как в classе Movie и дополнительными полями, которые необходимы, и каждый раз конвертировать из Movie в MovieResponse.

Есть лучший способ сделать это?

Точка annotations JSONIgnore заключается в том, чтобы сообщить DispatcherServlet (или какой-либо другой компонент в Spring обрабатывает ответ), чтобы игнорировать определенные поля, если эти поля являются нулевыми или иным образом опущены.

Это может обеспечить вам некоторую гибкость с точки зрения того, какие данные вы подвергаете клиенту в определенных случаях.

Нижняя сторона JSONIgnore:

Однако есть некоторые недостатки в использовании этой annotations, которую я недавно встречал в своих проектах. Это относится в основном к методу PUT и к случаям, когда объектом, который ваш controller сериализует данные, является тот же объект, который используется для хранения этих данных в базе данных.

Метод PUT подразумевает, что вы создаете новую коллекцию на сервере или заменяете коллекцию на сервере новой обновляемой коллекцией.

Пример замены коллекции на сервере:

Представьте, что вы делаете запрос PUT на свой сервер, а RequestBody содержит сериализованный объект Movie, но этот объект Movie не содержит актеров, потому что вы их опустили! Позже в будущем вы реализуете новую функцию, которая позволяет вашим пользователям редактировать и исправлять орфографические ошибки в описании фильма, и вы используете PUT для отправки объекта Movie обратно на сервер и обновления базы данных.

Но, скажем так, потому что это было так давно, когда вы добавили JSONIgnore к своим объектам – вы забыли, что некоторые поля являются необязательными. На стороне клиента вы забыли включить коллекцию актеров, и теперь ваш пользователь случайно перезаписывает фильм A с актерами B, C и D, с фильмом A без актеров вообще!

Почему JSONIgnore отказывается?

Разумеется, намерение, вынуждающее вас отказаться от создания определенных полей, является именно тем, что исключаются эти типы целостности данных. В мире, где вы не используете JSONIgnore, вы гарантируете, что ваши данные никогда не будут заменены частичными данными, если вы явно не установите эти данные самостоятельно. С JSONIgnore вы удаляете эти меры предосторожности.

С учетом сказанного JSONIgnore очень ценен, и я сам использую его точно таким же образом, чтобы уменьшить размер полезной нагрузки, отправленной клиенту. Тем не менее, я начинаю переосмысливать эту страtagsю и вместо этого выбираю ту, где я использую classы POJO на отдельном уровне для отправки данных во внешний интерфейс, чем то, что я использую для взаимодействия с базой данных.

Возможная настройка:

Идеальная настройка – из моего опыта, связанного с этой конкретной проблемой, – это использовать инъекцию конструктора для ваших объектов Entity вместо сеттеров. Заставляйте себя проходить в каждом параметре во время создания экземпляра, чтобы ваши объекты никогда не были частично заполнены. Если вы попытаетесь частично заполнить их, компилятор прекратит вам делать что-то, о чем вы можете пожалеть.

Для отправки данных на клиентскую сторону, где вы можете опустить определенные части данных, вы можете использовать отдельный отключенный объект POJO или использовать JSONObject из org.json.

При отправке данных с клиента на сервер, ваши объекты сущности интерфейса получают данные из слоя базы данных модели, частично или полностью, так как вам все равно, если внешний интерфейс получает частичные данные. Но затем, сохраняя данные в хранилище данных, вы сначала извлечете уже сохраненный объект из хранилища данных, обновите его свойства и затем сохраните его обратно в хранилище данных. Другими словами, если вам не хватало актеров, это не имело бы значения, поскольку объект, который вы обновляете из хранилища данных, уже имеет субъектов, назначенных его свойствам. Таким образом, вы заменяете только те поля, которые вы явно собираетесь заменить.

Хотя для этой настройки будет больше затрат на обслуживание и сложность, вы получите огромное преимущество: компилятор Java будет иметь вашу спину! Это не позволит вам или даже несчастному коллеге что-либо сделать в коде, который может поставить под угрозу данные в хранилище данных. Если вы попытаетесь создать объект «на лету» на уровне модели, вам придется использовать конструктор и принудительно предоставить все данные. Если у вас нет всех данных и вы не можете создать экземпляр объекта, вам нужно будет либо передать пустые значения (которые должны сигнализировать вам красный флаг), либо сначала получить данные из хранилища данных.

Я столкнулся с этой проблемой и действительно хотел продолжать использовать @JsonIgnore, но также использовать сущности / POJO для использования в вызовах JSON.

После большого рытья я придумал решение автоматически получать игнорируемые поля из базы данных при каждом вызове объекта mapper.

Конечно, есть некоторые требования, которые необходимы для этого решения. Подобно тому, как вы должны использовать repository, но в моем случае это работает так, как мне нужно.

Для этого вам нужно убедиться, что ObjectMapper в MappingJackson2HttpMessageConverter перехвачен, и поля, отмеченные с помощью @JsonIgnore, заполнены. Поэтому нам нужен наш собственный MappingJackson2HttpMessageConverter bean:


 public class MvcConfig extends WebMvcConfigurerAdapter { @Override public void extendMessageConverters(List> converters) { for (HttpMessageConverter converter : converters) { if (converter instanceof MappingJackson2HttpMessageConverter) { ((MappingJackson2HttpMessageConverter)converter).setObjectMapper(objectMapper()); } } } @Bean public ObjectMapper objectMapper() { ObjectMapper objectMapper = new FillIgnoredFieldsObjectMapper(); Jackson2ObjectMapperBuilder.json().configure(objectMapper); return objectMapper; } } 

Каждый запрос JSON преобразуется в объект нашим собственным objectMapper, который заполняет игнорируемые поля, извлекая их из репозитория:

 /** * Created by Sander Agricola on 18-3-2015. * * When fields or setters are marked as @JsonIgnore, the field is not read from the JSON and thus left empty in the object * When the object is a persisted entity it might get stored without these fields and overwriting the properties * which where set in previous calls. * * To overcome this property entities with ignored fields are detected. The same object is than retrieved from the * repository and all ignored fields are copied from the database object to the new object. */ @Component public class FillIgnoredFieldsObjectMapper extends ObjectMapper { final static Logger logger = LoggerFactory.getLogger(FillIgnoredFieldsObjectMapper.class); @Autowired ListableBeanFactory listableBeanFactory; @Override protected Object _readValue(DeserializationConfig cfg, JsonParser jp, JavaType valueType) throws IOException, JsonParseException, JsonMappingException { Object result = super._readValue(cfg, jp, valueType); fillIgnoredFields(result); return result; } @Override protected Object _readMapAndClose(JsonParser jp, JavaType valueType) throws IOException, JsonParseException, JsonMappingException { Object result = super._readMapAndClose(jp, valueType); fillIgnoredFields(result); return result; } /** * Find all ignored fields in the object, and fill them with the value as it is in the database * @param resultObject Object as it was deserialized from the JSON values */ public void fillIgnoredFields(Object resultObject) { Class c = resultObject.getClass(); if (!objectIsPersistedEntity(c)) { return; } List ignoredFields = findIgnoredFields(c); if (ignoredFields.isEmpty()) { return; } Field idField = findIdField(c); if (idField == null || getValue(resultObject, idField) == null) { return; } CrudRepository repository = findRepositoryForClass(c); if (repository == null) { return; } //All lights are green: fill the ignored fields with the persisted values fillIgnoredFields(resultObject, ignoredFields, idField, repository); } /** * Fill the ignored fields with the persisted values * * @param object Object as it was deserialized from the JSON values * @param ignoredFields List with fields which are marked as JsonIgnore * @param idField The id field of the entity * @param repository The repository for the entity */ private void fillIgnoredFields(Object object, List ignoredFields, Field idField, CrudRepository repository) { logger.debug("Object {} contains fields with @JsonIgnore annotations, retrieving their value from database", object.getClass().getName()); try { Object storedObject = getStoredObject(getValue(object, idField), repository); if (storedObject == null) { return; } for (Field field : ignoredFields) { field.set(object, getValue(storedObject, field)); } } catch (IllegalAccessException e) { logger.error("Unable to fill ignored fields", e); } } /** * Get the persisted object from database. * * @param id The id of the object (most of the time an int or string) * @param repository The The repository for the entity * @return The object as it is in the database * @throws IllegalAccessException */ @SuppressWarnings("unchecked") private Object getStoredObject(Object id, CrudRepository repository) throws IllegalAccessException { return repository.findOne((Serializable)id); } /** * Get the value of a field for an object * * @param object Object with values * @param field The field we want to retrieve * @return The value of the field in the object */ private Object getValue(Object object, Field field) { try { field.setAccessible(true); return field.get(object); } catch (IllegalAccessException e) { logger.error("Unable to access field value", e); return null; } } /** * Test if the object is a persisted entity * @param c The class of the object * @return true when it has an @Entity annotation */ private boolean objectIsPersistedEntity(Class c) { return c.isAnnotationPresent(Entity.class); } /** * Find the right repository for the class. Needed to retrieve the persisted object from database * * @param c The class of the object * @return The (Crud)repository for the class. */ private CrudRepository findRepositoryForClass(Class c) { return (CrudRepository)new Repositories(listableBeanFactory).getRepositoryFor(c); } /** * Find the Id field of the object, the Id field is the field with the @Id annotation * * @param c The class of the object * @return the id field */ private Field findIdField(Class c) { for (Field field : c.getDeclaredFields()) { if (field.isAnnotationPresent(Id.class)) { return field; } } return null; } /** * Find a list of all fields which are ignored by json. * In some cases the field itself is not ignored, but the setter is. In this case this field is also returned. * * @param c The class of the object * @return List with ignored fields */ private List findIgnoredFields(Class c) { List ignoredFields = new ArrayList(); for (Field field : c.getDeclaredFields()) { //Test if the field is ignored, or the setter is ignored. //When the field is ignored it might be overridden by the setter (by adding @JsonProperty to the setter) if (fieldIsIgnored(field) ? setterDoesNotOverrideIgnore(field) : setterIsIgnored(field)) { ignoredFields.add(field); } } return ignoredFields; } /** * @param field The field we want to retrieve * @return True when the field is ignored by json */ private boolean fieldIsIgnored(Field field) { return field.isAnnotationPresent(JsonIgnore.class); } /** * @param field The field we want to retrieve * @return true when the setter is ignored by json */ private boolean setterIsIgnored(Field field) { return annotationPresentAtSetter(field, JsonIgnore.class); } /** * @param field The field we want to retrieve * @return true when the setter is NOT ignored by json, overriding the property of the field. */ private boolean setterDoesNotOverrideIgnore(Field field) { return !annotationPresentAtSetter(field, JsonProperty.class); } /** * Test if an annotation is present at the setter of a field. * * @param field The field we want to retrieve * @param annotation The annotation looking for * @return true when the annotation is present */ private boolean annotationPresentAtSetter(Field field, Class annotation) { try { Method setter = getSetterForField(field); return setter.isAnnotationPresent(annotation); } catch (NoSuchMethodException e) { return false; } } /** * Get the setter for the field. The setter is found based on the name with "set" in front of it. * The type of the field must be the only parameter for the method * * @param field The field we want to retrieve * @return Setter for the field * @throws NoSuchMethodException */ @SuppressWarnings("unchecked") private Method getSetterForField(Field field) throws NoSuchMethodException { Class c = field.getDeclaringClass(); return c.getDeclaredMethod(getSetterName(field.getName()), field.getType()); } /** * Build the setter name for a fieldName. * The Setter name is the name of the field with "set" in front of it. The first character of the field * is set to uppercase; * * @param fieldName The name of the field * @return The name of the setter */ private String getSetterName(String fieldName) { return String.format("set%C%s", fieldName.charAt(0), fieldName.substring(1)); } } 

Возможно, это не самое чистое решение во всех случаях, но в моем случае это делает трюк именно так, как я хочу, чтобы он работал.