streamalism.org

1. Oversikt

ORMLite er et lett ORM-bibliotek for Java-applikasjoner. Det gir standardfunksjoner i et ORM-verktøy for de vanligste brukssakene, uten ekstra kompleksitet og overhead til andre ORM-rammer.

Hovedtrekkene er:

• definere enhetsklasser ved hjelp av Java-merknader
• utvidbar DAO klasser
• en QueryBuilder klasse for å lage komplekse spørsmål
• genererte klasser for å lage og slippe databasetabeller
• støtte for transaksjoner
• støtte for enhetsrelasjoner

I de neste seksjonene vil vi se på hvordan vi kan sette opp biblioteket, definere enhetsklasser og utføre operasjoner på databasen ved hjelp av biblioteket.

2. Maven-avhengigheter

For å begynne å bruke ORMLite, må vi legge til ormlite-jdbc avhengighet til vår pom.xml:

 com.j256.ormlite ormlite-jdbc 5.0 

Som standard bringer dette også inn h2 avhengighet. I eksemplene våre bruker vi en H2 in-memory database, slik at vi ikke trenger en annen JDBC-driver.

Hvis du vil bruke en annen database, trenger du også den tilsvarende avhengigheten.

3. Definere enhetsklasser

For å sette opp modellklassene våre for utholdenhet med ORMLite, er det to primære merknader vi kan bruke:

• @DatabaseTable for enhetsklassen
• @DatabaseField for eiendommene

La oss starte med å definere en Bibliotek enhet med en Navn felt og en libraryId felt som også er en hovednøkkel:

@DatabaseTable (tableName = "biblioteker") public class Library {@DatabaseField (generatedId = true) private long libraryId; @DatabaseField (canBeNull = false) privat strengnavn; public Library () {} // standard getters, setters}

De @DatabaseTable merknader har en valgfri tabellnavn attributt som spesifiserer navnet på tabellen hvis vi ikke vil stole på et standard klassenavn.

For hvert felt vi vil fortsette som en kolonne i databasetabellen, må vi legge til @DatabaseField kommentar.

Eiendommen som vil fungere som en hovednøkkel for tabellen, kan merkes med en av dem id, generatedId eller generatedSequence attributter. I vårt eksempel velger vi generatedId = true attributt slik at primærnøkkelen økes automatisk.

Legg også merke til at klassen må ha en konstruktør uten argument med minst pakke-omfang synlighet.

Noen få andre kjente attributter vi kan bruke til å konfigurere feltene er kolonnenavn, data-type, standardverdi, canBeNull, unik.

3.1. Ved hjelp av JPA Kommentarer

I tillegg til de ORML-spesifikke kommentarene, vi kan også bruke JPA-stil merknader for å definere enhetene våre.

Tilsvarende av Bibliotek enhet vi definerte før bruk JPA standardkommentarer vil være:

@Entity offentlig klasse LibraryJPA {@Id @GeneratedValue (strategi = GenerationType.IDENTITY) privat lang libraryId; @Kolonne privat strengnavn; // standard getters, setters}

Selv om ORMLite gjenkjenner disse kommentarene, må vi fortsatt legge til javax.persistence-api avhengighet for å bruke dem.

Den komplette listen over støttede JPA merknader er @Enhet, @Id,@Kolonne,@GeneratedValue, @OneToOne, @ManyToOne, @Bli med i kolonnen, @Versjon.

4. ConnectionSource

For å jobbe med objektene som er definert, vi trenger å sette opp en ConnectionSource.

For dette kan vi bruke JdbcConnectionSource klasse som skaper en enkelt forbindelse, eller JdbcPooledConnectionSource som representerer en enkel samlet tilkoblingskilde:

JdbcPooledConnectionSource connectionSource = ny JdbcPooledConnectionSource ("jdbc: h2: mem: myDb"); // arbeid med connectionSource connectionSource.close ();

Andre eksterne datakilder med bedre ytelse kan også brukes ved å pakke dem inn i en DataSourceConnectionSource gjenstand.

5. TableUtils Klasse

Basert på ConnectionSource, vi kan bruke statiske metoder fra TableUtils klasse for å utføre operasjoner på databaseskjemaet:

• createTable () - å lage en tabell basert på en definisjon av en enhetsklasse eller en DatabaseTableConfig gjenstand
• createTableIfNotExists () - ligner på den forrige metoden, bortsett fra at den bare oppretter tabellen hvis den ikke eksisterer; dette fungerer bare på databaser som støtter det
• dropTable () - for å slette en tabell
• klar tabell() - for å slette dataene fra en tabell

La oss se hvordan vi kan bruke TableUtils å lage bordet for vår Bibliotek klasse:

TableUtils.createTableIfNotExists (connectionSource, Library.class);

6. DAO Objekter

ORMLite inneholder en DaoManager klasse som kan skape DAO objekter for oss med CRUD-funksjonalitet:

Dao libraryDao = DaoManager.createDao (connectionSource, Library.class);

De DaoManager regenererer ikke klassen for hver påfølgende samtale av createDao (), men bruker den i stedet for bedre ytelse.

Deretter kan vi utføre CRUD-operasjoner på Bibliotek gjenstander:

Bibliotekbibliotek = nytt Bibliotek (); library.setName ("Mitt bibliotek"); libraryDao.create (bibliotek); Biblioteksresultat = libraryDao.queryForId (1L); library.setName ("Mitt andre bibliotek"); libraryDao.update (bibliotek); libraryDao.delete (bibliotek);

De DAO er også en iterator som kan gå gjennom alle postene:

libraryDao.forEach (lib -> {System.out.println (lib.getName ());});

ORMLite lukker imidlertid bare den underliggende SQL-setningen hvis sløyfen går helt til slutten. Et unntak eller en returoppgave kan føre til en ressurslekkasje i koden din.

Av den grunn anbefaler ORMLite-dokumentasjonen at vi bruker iteratoren direkte:

prøv (CloseableWrappedIterable wrappedIterable = libraryDao.getWrappedIterable ()) {wrappedIterable.forEach (lib -> {System.out.println (lib.getName ());}); }

På denne måten kan vi lukke iteratoren ved hjelp av en prøv-med-ressurser eller a endelig blokker og unngå ressurslekkasje.

6.1. Tilpasset DAO-klasse

Hvis vi ønsker å utvide oppførselen til DAO objekter gitt, kan vi opprette et nytt grensesnitt som utvider Dao type:

offentlig grensesnitt LibraryDao utvider Dao {public List findByName (String name) kaster SQLException; }

La oss deretter legge til en klasse som implementerer dette grensesnittet og utvider BaseDaoImpl klasse:

public class LibraryDaoImpl utvider BaseDaoImpl implementerer LibraryDao {public LibraryDaoImpl (ConnectionSource connectionSource) kaster SQLException {super (connectionSource, Library.class); } @ Override public List findByName (strengnavn) kaster SQLException {return super.queryForEq ("navn", navn); }}

Merk at vi må ha en konstruktør av dette skjemaet.

Til slutt, for å bruke vår skikk DAO, vi må legge til klassenavnet i Bibliotek klassedefinisjon:

@DatabaseTable (tableName = "biblioteker", daoClass = LibraryDaoImpl.class) bibliotek i offentlig klasse {// ...}

Dette gjør at vi kan bruke DaoManager for å lage en forekomst av vår tilpassede klasse:

LibraryDao customLibraryDao = DaoManager.createDao (connectionSource, Library.class);

Da kan vi bruke alle metodene fra standarden DAO klasse, samt vår tilpassede metode:

Bibliotekbibliotek = nytt Bibliotek (); library.setName ("Mitt bibliotek"); customLibraryDao.create (bibliotek); assertEquals (1, customLibraryDao.findByName ("Mitt bibliotek"). størrelse ());

7. Definere enhetsrelasjoner

ORMLite bruker konseptet med "fremmede" objekter eller samlinger for å definere forhold mellom enheter for utholdenhet.

La oss ta en titt på hvordan vi kan definere hver type felt.

7.1. Felt for fremmedlegemer

Vi kan opprette et ensidig en-til-ett forhold mellom to enhetsklasser ved å bruke fremmed = sant attributt på et felt merket med @DatabaseField. Feltet må være av en type som også vedvarer i databasen.

La oss først definere en ny enhetsklasse som heter Adresse:

@DatabaseTable (tabellnavn = "adresser") offentlig klasse Adresse {@DatabaseField (generatedId = true) privat lang adresseId; @DatabaseField (canBeNull = false) privat strengadresselinje; // standard getters, setters}

Deretter kan vi legge til et felt av typen Adresse til vår Bibliotek klasse som er merket som fremmed:

@DatabaseTable (tableName = "libraries") public class Library {// ... @DatabaseField (foreign = true, foreignAutoCreate = true, foreignAutoRefresh = true) privat adresse adresse; // standard getters, setters}

Legg merke til at vi også har lagt til to attributter til @DatabaseField kommentar: ForeignAutoCreate og ForeignAutoRefresh, begge satt til ekte.

De foreignAutoCreate = true attributt betyr at når vi lagrer en Bibliotek objekt med en adresse felt, vil også fremmedlegemet bli lagret, forutsatt at det er id er ikke null og har en generatedId = true Egenskap.

Hvis vi setter oss ForeignAutoCreate til falsk, som er standardverdien, må vi vedvare det fremmedlegemet eksplisitt før vi lagrer Bibliotek objekt som refererer til det.

Tilsvarende ForeignAutoRefresh=ekte attributt angir at når du henter en Bibliotek gjenstand, vil den tilknyttede fremmedlegemet også bli hentet. Ellers må vi oppdatere det manuelt.

La oss legge til en ny Bibliotek objekt med en Adresse feltet og ring bibliotekDao å vedvare begge:

Bibliotekbibliotek = nytt Bibliotek (); library.setName ("Mitt bibliotek"); library.setAddress (ny adresse ("Main Street nr 20")); Dao libraryDao = DaoManager.createDao (connectionSource, Library.class); libraryDao.create (bibliotek);

Så kan vi ringe adresseDao for å bekrefte at Adresse er også lagret:

Dao addressDao = DaoManager.createDao (connectionSource, Address.class); assertEquals (1, addressDao.queryForEq ("addressLine", "Main Street nr 20") .størrelse ());

7.2. Utenlandske samlinger

For mange side av et forhold, kan vi bruke typene ForeignCollection eller Samling med en @ForeignCollectionField kommentar.

La oss lage et nytt Bok enhet som de ovenfor, og legg deretter til en-til-mange-relasjon i Bibliotek klasse:

@DatabaseTable (tableName = "libraries") public class Library {// ... @ForeignCollectionField (ivrig = falsk) private ForeignCollection-bøker; // standard getters, setters}

I tillegg til dette kreves det at vi legger til et felt av typen Bibliotek i Bok klasse:

@DatabaseTable public class Book {// ... @DatabaseField (fremmed = sant, fremmedAutoRefresh = sant) privat bibliotekbibliotek; // standard getters, setters}

De ForeignCollection har legge til() og fjerne() metoder som opererer på typene Bok:

Bibliotekbibliotek = nytt Bibliotek (); library.setName ("Mitt bibliotek"); libraryDao.create (bibliotek); libraryDao.refresh (bibliotek); library.getBooks (). legg til (ny bok ("1984"));

Her har vi opprettet en bibliotek objekt, og deretter lagt til et nytt Bok motsette seg bøker feltet, som også fortsetter det til databasen.

Vær oppmerksom på at siden samlingen vår er merket som lat ladet (ivrig = falsk), vi må ringe forfriske() metode før du kan bruke bokfeltet.

Vi kan også opprette forholdet ved å sette bibliotek felt i Bok klasse:

Bokbok = ny bok ("Det"); book.setLibrary (bibliotek); bookDao.create (bok);

For å verifisere at begge deler Bok gjenstander legges til bibliotek vi kan bruke queryForEq () metode for å finne alle Bok poster med det gitte bibliotek_id:

assertEquals (2, bookDao.queryForEq ("bibliotek_id", bibliotek) .størrelse ());

Her, den bibliotek_id er standardnavnet på den utenlandske nøkkelkolonnen, og primærnøkkelen er utledet fra bibliotek gjenstand.

8. QueryBuilder

Hver DAO kan brukes til å skaffe en QueryBuilder objekt som vi deretter kan utnytte for å bygge kraftigere spørsmål.

Denne klassen inneholder metoder som tilsvarer vanlige operasjoner som brukes i et SQL-spørsmål, for eksempel: selectColumns (), hvor (), groupBy (),å ha (), countOf (), distinkt (), orderBy (), bli med ().

La oss se et eksempel på hvordan vi kan finne alle Bibliotek poster som har mer enn en Bok assosiert:

Listebiblioteker = libraryDao.queryBuilder () .where () .in ("libraryId", bookDao.queryBuilder () .selectColumns ("library_id") .groupBy ("library_id") .having ("count (*)> 1") ). spørring ();

9. Konklusjon

I denne artikkelen har vi sett hvordan vi kan definere enheter ved hjelp av ORMLite, samt hovedfunksjonene i biblioteket som vi kan bruke til å manipulere objekter og deres tilknyttede relasjonsdatabaser.

Den fulle kildekoden til eksemplet finner du på GitHub.