Customizing HATEOAS link-Generierung für Personen mit composite ids

Ich so konfiguriert haben, dass ein RepositoryRestResource auf eine PageAndSortingRepository zugreift, eine Einheit, die beinhaltet ein composite-Id:

@Entity
@IdClass(CustomerId.class)
public class Customer {
    @Id BigInteger id;
    @Id int startVersion;
    ...
}

public class CustomerId {
    BigInteger id;
    int startVersion;
    ...
}

@RepositoryRestResource(collectionResourceRel = "customers", path = "customers", itemResourceRel = "customers/{id}_{startVersion}")
public interface CustomerRepository extends PagingAndSortingRepository<Customer, CustomerId> {}

Wenn ich auf den server zugreifen zu "http://<server>/api/customers/1_1" zum Beispiel, bekomme ich die richtige Ressource wieder als json, aber die href in der _links Abschnitt für sich selbst ist, das falsche und das gleiche auch für alle anderen Kunden, die ich Abfrage: "http://<server>/api/customer/1"

d.h.:

{
  "id" : 1,
  "startVersion" : 1,
  ...
  "firstname" : "BOB",
  "_links" : {
    "self" : {
      "href" : "http://localhost:9081/reps/api/reps/1" <-- This should be /1_1
    }
  }
}

Ich vermute, das ist wegen meiner composite-Id, Aber ich bin chuffed, wie ich das ändern kann das Standard-Verhalten.

Hatte, habe ich einen Blick auf die ResourceSupport und die ResourceProcessor Klasse, aber bin mir nicht sicher, wie viel ich ändern muss, um dieses Problem zu beheben.

Kann jemand, der weiß, Feder Leih mir eine hand?

InformationsquelleAutor coderatchet | 2014-05-22

Leider alle Spring-Data-JPA/Rest bis Version 2.1.0.RELEASE sind nicht in der Lage, zu dienen, Ihren Bedarf aus der box.
Die Quelle wird begraben inside Spring Data Commons/JPA selbst. Spring Data JPA unterstützt nur Id und EmbeddedId als Bezeichner.

Auszug JpaPersistentPropertyImpl:

static {

    //[...]

    annotations = new HashSet<Class<? extends Annotation>>();
    annotations.add(Id.class);
    annotations.add(EmbeddedId.class);

    ID_ANNOTATIONS = annotations;
}

Spring Data Commons nicht unterstützen das Konzept der kombinierten Eigenschaften. Er behandelt jede Eigenschaft einer Klasse unabhängig voneinander.

Natürlich können Sie hack Spring Data Rest. Aber dies ist mühsam, nicht das problem löst, in Ihrem Herzen und reduziert die Flexibilität des Frameworks.

Hier ist der hack. Dies sollte Ihnen eine Idee geben, wie Sie zur Bewältigung Ihres Problems.

In Ihrer Konfiguration überschreiben repositoryExporterHandlerAdapter und zurückgeben CustomPersistentEntityResourceAssemblerArgumentResolver.
Darüber hinaus überschreiben backendIdConverterRegistry und fügen Sie CustomBackendIdConverter zu der Liste der bekannten id converter:

import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.rest.core.projection.ProxyProjectionFactory;
import org.springframework.data.rest.webmvc.RepositoryRestHandlerAdapter;
import org.springframework.data.rest.webmvc.config.RepositoryRestMvcConfiguration;
import org.springframework.data.rest.webmvc.spi.BackendIdConverter;
import org.springframework.data.rest.webmvc.support.HttpMethodHandlerMethodArgumentResolver;
import org.springframework.data.web.config.EnableSpringDataWebSupport;
import org.springframework.hateoas.ResourceProcessor;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.plugin.core.OrderAwarePluginRegistry;
import org.springframework.plugin.core.PluginRegistry;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Configuration
@Import(RepositoryRestMvcConfiguration.class)
@EnableSpringDataWebSupport
public class RestConfig extends RepositoryRestMvcConfiguration {
    @Autowired(required = false) List<ResourceProcessor<?>> resourceProcessors = Collections.emptyList();
    @Autowired
    ListableBeanFactory beanFactory;

    @Override
    @Bean
    public PluginRegistry<BackendIdConverter, Class<?>> backendIdConverterRegistry() {

        List<BackendIdConverter> converters = new ArrayList<BackendIdConverter>(3);
        converters.add(new CustomBackendIdConverter());
        converters.add(BackendIdConverter.DefaultIdConverter.INSTANCE);

        return OrderAwarePluginRegistry.create(converters);
    }

    @Bean
    public RequestMappingHandlerAdapter repositoryExporterHandlerAdapter() {

        List<HttpMessageConverter<?>> messageConverters = defaultMessageConverters();
        configureHttpMessageConverters(messageConverters);

        RepositoryRestHandlerAdapter handlerAdapter = new RepositoryRestHandlerAdapter(defaultMethodArgumentResolvers(),
                resourceProcessors);
        handlerAdapter.setMessageConverters(messageConverters);

        return handlerAdapter;
    }

    private List<HandlerMethodArgumentResolver> defaultMethodArgumentResolvers()
    {

        CustomPersistentEntityResourceAssemblerArgumentResolver peraResolver = new CustomPersistentEntityResourceAssemblerArgumentResolver(
                repositories(), entityLinks(), config().projectionConfiguration(), new ProxyProjectionFactory(beanFactory));

        return Arrays.asList(pageableResolver(), sortResolver(), serverHttpRequestMethodArgumentResolver(),
                repoRequestArgumentResolver(), persistentEntityArgumentResolver(),
                resourceMetadataHandlerMethodArgumentResolver(), HttpMethodHandlerMethodArgumentResolver.INSTANCE,
                peraResolver, backendIdHandlerMethodArgumentResolver());
    }
}

Erstellen CustomBackendIdConverter. Diese Klasse ist verantwortlich für die Darstellung Ihrer benutzerdefinierten Entität ids:

import org.springframework.data.rest.webmvc.spi.BackendIdConverter;

import java.io.Serializable;

public class CustomBackendIdConverter implements BackendIdConverter {

    @Override
    public Serializable fromRequestId(String id, Class<?> entityType) {
        return id;
    }

    @Override
    public String toRequestId(Serializable id, Class<?> entityType) {
        if(entityType.equals(Customer.class)) {
            Customer c = (Customer) id;
            return c.getId() + "_" +c.getStartVersion();
        }
        return id.toString();

    }

    @Override
    public boolean supports(Class<?> delimiter) {
        return true;
    }
}

CustomPersistentEntityResourceAssemblerArgumentResolver wiederum zurückgeben sollte eine CustomPersistentEntityResourceAssembler:

import org.springframework.core.MethodParameter;
import org.springframework.data.repository.support.Repositories;
import org.springframework.data.rest.core.projection.ProjectionDefinitions;
import org.springframework.data.rest.core.projection.ProjectionFactory;
import org.springframework.data.rest.webmvc.PersistentEntityResourceAssembler;
import org.springframework.data.rest.webmvc.config.PersistentEntityResourceAssemblerArgumentResolver;
import org.springframework.data.rest.webmvc.support.PersistentEntityProjector;
import org.springframework.hateoas.EntityLinks;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.ModelAndViewContainer;

public class CustomPersistentEntityResourceAssemblerArgumentResolver extends PersistentEntityResourceAssemblerArgumentResolver {
    private final Repositories repositories;
    private final EntityLinks entityLinks;
    private final ProjectionDefinitions projectionDefinitions;
    private final ProjectionFactory projectionFactory;

    public CustomPersistentEntityResourceAssemblerArgumentResolver(Repositories repositories, EntityLinks entityLinks,
                                                             ProjectionDefinitions projectionDefinitions, ProjectionFactory projectionFactory) {

        super(repositories, entityLinks,projectionDefinitions,projectionFactory);

        this.repositories = repositories;
        this.entityLinks = entityLinks;
        this.projectionDefinitions = projectionDefinitions;
        this.projectionFactory = projectionFactory;
    }

    public boolean supportsParameter(MethodParameter parameter) {
        return PersistentEntityResourceAssembler.class.isAssignableFrom(parameter.getParameterType());
    }

    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

        String projectionParameter = webRequest.getParameter(projectionDefinitions.getParameterName());
        PersistentEntityProjector projector = new PersistentEntityProjector(projectionDefinitions, projectionFactory,
                projectionParameter);

        return new CustomPersistentEntityResourceAssembler(repositories, entityLinks, projector);
    }
}

CustomPersistentEntityResourceAssembler muss überschreiben getSelfLinkFor. Wie Sie sehen können entity.getIdProperty() wieder entweder id oder startVersion Eigentum Ihrer Customer - Klasse, die wiederum wird verwendet, um den realen Wert, der mit Hilfe eines BeanWrapper. Wir sind hier zu einem Kurzschluss der ganze Rahmen mit dem Einsatz von instanceof Betreiber. Damit Ihre Customer Klasse implementieren sollte Serializable für die weitere Verarbeitung.

import org.springframework.data.mapping.PersistentEntity;
import org.springframework.data.mapping.model.BeanWrapper;
import org.springframework.data.repository.support.Repositories;
import org.springframework.data.rest.webmvc.PersistentEntityResourceAssembler;
import org.springframework.data.rest.webmvc.support.Projector;
import org.springframework.hateoas.EntityLinks;
import org.springframework.hateoas.Link;
import org.springframework.util.Assert;

public class CustomPersistentEntityResourceAssembler extends PersistentEntityResourceAssembler {

    private final Repositories repositories;
    private final EntityLinks entityLinks;

    public CustomPersistentEntityResourceAssembler(Repositories repositories, EntityLinks entityLinks, Projector projector) {
        super(repositories, entityLinks, projector);

        this.repositories = repositories;
        this.entityLinks = entityLinks;
    }

    public Link getSelfLinkFor(Object instance) {

        Assert.notNull(instance, "Domain object must not be null!");

        Class<? extends Object> instanceType = instance.getClass();
        PersistentEntity<?, ?> entity = repositories.getPersistentEntity(instanceType);

        if (entity == null) {
            throw new IllegalArgumentException(String.format("Cannot create self link for %s! No persistent entity found!",
                    instanceType));
        }

        Object id;

        //this is a hack for demonstration purpose. don't do this at home!
        if(instance instanceof Customer) {
            id = instance;
        } else {
            BeanWrapper<Object> wrapper = BeanWrapper.create(instance, null);
            id = wrapper.getProperty(entity.getIdProperty());
        }

        Link resourceLink = entityLinks.linkToSingleResource(entity.getType(), id);
        return new Link(resourceLink.getHref(), Link.REL_SELF);
    }
}

Das ist es! Sie sollten sehen, diese URIs:

{
  "_embedded" : {
    "customers" : [ {
      "name" : "test",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/demo/customers/1_1"
        }
      }
    } ]
  }
}

Imho, wenn man auf einem grünen Feld-Projekt würde ich vorschlagen, zu Graben IdClass vollständig und gehen mit technisch einfachen ids, basierend auf Lang-Klasse. Getestet wurde dies mit Spring Data Rest 2.1.0.RELEASE, Spring data JPA 1.6.0.RELEASE-und Spring-Framework 4.0.3.RELEASE.

kein problem. es ist ein Interessantes problem. hoffe, es hilft. vielleicht brauchen Sie zur Umsetzung fromRequestId Deserialisieren Ihre ids.
Gute Antwort! Ich habe nicht versucht es noch, aber dieses repository akzeptieren POST-Anfragen? Wie kann ich einfügen-Daten über REST-API?

InformationsquelleAutor Kamill Sokol

4

Zwar nicht wünschenswert, ich habe gearbeitet, um dieses Problem durch die Verwendung eines @EmbeddedId statt einer IdClass Anmerkung auf meine JPA-entity.

Etwa so:
```
@Entity
public class Customer {
    @EmbeddedId
    private CustomerId id;
    ...
}

public class CustomerId {

    @Column(...)
    BigInteger key;
    @Column(...)
    int startVersion;
    ...
}
```
Jetzt sehe ich die korrekt generierten links 1_1 auf meinem zurückgegebenen Entitäten.

Wenn jemand noch mir eine Lösung, die nicht erfordert, ändere ich die Darstellung meines Modells, Es würde sehr geschätzt werden. Zum Glück hatte ich nicht weit Fortgeschritten in meiner Anwendung Entwicklung um dies zu ernsthaften Bedenken in wechselnden, aber ich kann mir vorstellen, dass für andere, es würde zu einem erheblichen Mehraufwand bei der Durchführung einer änderung wie diese: (z.B. Wechsel alle Abfragen, die die Referenz dieses Modells in JPQL-queries).
- Ich weiß, dies ist eine alte post, aber ich dachte, ich würde hinzufügen, Sie können hinzufügen @Transient zu einem getKey Methode, die zurück id.key im Customer dass können Sie haben einen schnellen Zugriff in der API aber wird nicht auf Ihre ERHOLUNG Darstellung. Es ist hässlich, aber macht Ihr API-Reiniger.
- IMHO beste Weg zu gehen
InformationsquelleAutor coderatchet
0

Ich hatte ein ähnliches problem, wo der zusammengesetzte Schlüssel Szenarien für die data rest war nicht arbeiten. @ksokol ausführliche Erklärung, sofern die notwendigen inputs, um das Problem zu lösen. geändert, meine pom in Erster Linie für Daten-Erholung-webmvc und Daten-jpa als
```
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-rest-webmvc</artifactId>
        <version>2.2.1.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>1.7.1.RELEASE</version>
    </dependency>
```
die Lösung all der Fragen, die mit einem zusammengesetzten Schlüssel und ich brauche nicht die Anpassung. Dank ksokol für die ausführliche Erklärung.
- Hallo @Alagesan, Sie wissen, was sind die Spring Data JPA oder REST-version, die das problem gelöst? Dank
InformationsquelleAutor Alagesan Pandy

Erstellen Sie zunächst eine SpringUtil zu bekommen bean von spring.

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if(SpringUtil.applicationContext == null) {
            SpringUtil.applicationContext = applicationContext;
        }
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Object getBean(String name){
        return getApplicationContext().getBean(name);
    }

    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name,Class<T> clazz){
        return getApplicationContext().getBean(name, clazz);
    }
}

Dann, implementieren BackendIdConverter.

import com.alibaba.fastjson.JSON;
import com.example.SpringUtil;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.rest.webmvc.spi.BackendIdConverter;
import org.springframework.stereotype.Component;

import javax.persistence.EmbeddedId;
import javax.persistence.Id;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.net.URLEncoder;

@Component
public class CustomBackendIdConverter implements BackendIdConverter {

    @Override
    public boolean supports(Class<?> delimiter) {
        return true;
    }

    @Override
    public Serializable fromRequestId(String id, Class<?> entityType) {
        if (id == null) {
            return null;
        }

        //first decode url string
        if (!id.contains(" ") && id.toUpperCase().contains("%7B")) {
            try {
                id = URLDecoder.decode(id, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }

        //deserialize json string to ID object
        Object idObject = null;
        for (Method method : entityType.getDeclaredMethods()) {
            if (method.isAnnotationPresent(Id.class) || method.isAnnotationPresent(EmbeddedId.class)) {
                idObject = JSON.parseObject(id, method.getGenericReturnType());
                break;
            }
        }

        //get dao class from spring
        Object daoClass = null;
        try {
            daoClass = SpringUtil.getBean(Class.forName("com.example.db.dao." + entityType.getSimpleName() + "DAO"));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //get the entity with given primary key
        JpaRepository simpleJpaRepository = (JpaRepository) daoClass;
        Object entity = simpleJpaRepository.findOne((Serializable) idObject);
        return (Serializable) entity;

    }

    @Override
    public String toRequestId(Serializable id, Class<?> entityType) {
        if (id == null) {
            return null;
        }

        String jsonString = JSON.toJSONString(id);

        String encodedString = "";
        try {
            encodedString = URLEncoder.encode(jsonString, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return encodedString;
    }
}

Danach. Sie können tun, was Sie wollen.

Es ist ein Beispiel unten.

Wenn das Unternehmen hat eine einzige Eigenschaft pk, die Sie verwenden können
localhost:8080/demo/1 als normal. Nach meinem code nehme an der pk
hat eine annotation "@Id".
Wenn das Unternehmen hat komponiert, pk angenommen, die pk ist demoId Typ, und hat
die annotation "@EmbeddedId", können Sie localhost:8080/demo/{demoId
json} to get/put/delete. Und dein selbst wird der link der gleiche ist.

InformationsquelleAutor kidfruit

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.