JPA-annotatie voor het PostgreSQL-TEKST-type

1. Inleiding

In deze korte tutorial, we zullen uitleggen hoe u het PostgreSQL TEXT-type kunt beheren met behulp van de annotaties die zijn gedefinieerd door de JPA-specificatie.

2. De TEKST Typ PostgreSQL

Als we met PostgresSQL werken, is het mogelijk dat we periodiek een string met een willekeurige lengte moeten opslaan.

Hiervoor biedt PostgreSQL drie soorten tekens:

  • CHAR (n)
  • VARCHAR (n)
  • TEKST

Helaas maakt het TEXT-type geen deel uit van de typen die worden beheerd door de SQL-standaard. Dit betekent dat als we JPA-annotaties willen gebruiken in onze persistentie-entiteiten, we mogelijk een probleem hebben.

Dit komt doordat de JPA-specificatie gebruik maakt van de SQL-standaard. Bijgevolg is het definieert geen eenvoudige manier om met dit type object om te gaan, bijvoorbeeld met een @Tekst annotatie.

Gelukkig hebben we een aantal mogelijkheden voor het beheren van het TEXT-gegevenstype voor een PostgreSQL-database:

  • We kunnen de @Lob annotatie
  • Als alternatief kunnen we ook de @Kolom annotatie, gecombineerd met de columnDefinition attribuut

Laten we nu eens kijken naar de twee oplossingen die beginnen met de @Lob annotatie.

3. @Lob

Zoals de naam al doet vermoeden, is een lob een large object. In databasetermen, lob-kolommen worden gebruikt om zeer lange teksten of binaire bestanden op te slaan.

We kunnen kiezen uit twee soorten lobs:

  • CLOB - een karakterlob die wordt gebruikt om teksten op te slaan
  • BLOB - een binaire lob die kan worden gebruikt om binaire gegevens op te slaan

We kunnen de PPV gebruiken @Lob annotatie om grote velden toe te wijzen aan grote databaseobjecttypen.

Wanneer we de @Lob record op een Draad type attribuut, zegt de JPA-specificatie dat de persistentieprovider een object met een groot karaktertype moet gebruiken om de waarde van het attribuut op te slaan. Bijgevolg kan PostgreSQL een karakterlob vertalen naar een TEXT-type.

Laten we aannemen dat we een simpele hebben Examen entiteitsobject, met een Omschrijving veld, dat een willekeurige lengte kan hebben:

@Entity openbare klasse Examen {@Id @GeneratedValue (strategie = GenerationType.AUTO) privé Lange id; @Lob private String beschrijving; } 

De ... gebruiken @Lob annotatie op het beschrijvingsveld, we instrueren Hibernate om dit veld te beheren met behulp van het PostgreSQL TEXT-type.

4. @Kolom

Een andere optie voor het beheren van het TEXT-type is om de @Kolom annotatie, samen met de columnDefinition eigendom.

Laten we hetzelfde gebruiken Examen entiteitsobject opnieuw, maar deze keer voegen we een TEXT-veld toe, dat een willekeurige lengte kan hebben:

@Entity openbare klasse Examen {@Id @GeneratedValue (strategie = GenerationType.AUTO) privé Lange id; @Lob private String beschrijving; @Column (columnDefinition = "TEXT") privé String-tekst; }

In dit voorbeeld gebruiken we de annotatie @Column (columnDefinition = ”TEXT”). De ... gebruiken columnDefinition attribuut stelt ons in staat het SQL-fragment te specificeren dat zal worden gebruikt bij het construeren van de gegevenskolom voor dit type.

5. Alles samenbrengen

In deze sectie zullen we een eenvoudige unit-test schrijven om te controleren of onze oplossing werkt:

@Test openbare ongeldig gegevenExam_whenSaveExam_thenReturnExpectedExam () {Examenexamen = nieuw examen (); exam.setDescription ("Dit is een beschrijving. Soms kan de beschrijving erg lang zijn!"); exam.setText ("Dit is een tekst. Soms kan de tekst erg lang zijn!"); exam = examRepository.save (examen); assertEquals (examRepository.find (exam.getId ()), examen); }

In dit voorbeeld beginnen we met het maken van een nieuw Examen object en zet het voort in onze database. We halen dan het Examen object uit de database en vergelijk het resultaat met het originele onderzoek dat we hebben gemaakt.

Om het punt te demonstreren, als we snel het beschrijvingsveld op onze Examen entiteit:

@Column (lengte = 20) private String beschrijving; 

Wanneer we onze test opnieuw uitvoeren, zien we een foutmelding:

FOUT o.h.e.jdbc.spi.SqlExceptionHelper - Waarde te lang voor kolom "TEXT VARCHAR (20)"

6. Conclusie

In deze tutorial hebben we twee benaderingen behandeld voor het gebruik van JPA-annotaties met het PostgreSQL TEXT-type.

We begonnen met uit te leggen waarvoor het TEXT-type wordt gebruikt en daarna hebben we gezien hoe we de PPV-annotaties kunnen gebruiken @Lob en @Kolom opslaan Draad objecten met het TEXT-type gedefinieerd door PostgreSQL.

Zoals altijd is de volledige broncode van het artikel beschikbaar op GitHub.