An IT Expert PKBase - Wkład użytkownika [pl]

Kategoria:Hibernate

2026-05-21T20:55:25Z

Administrator: Utworzono nową stronę "Hibernate articles"

Hibernate articles

MediaWiki:Sidebar

2026-05-21T20:54:12Z

Administrator:

* navigation
** https://przybylowicz.it|Home
** mainpage|PKBase
** specialpages-url|specialpages
* SEARCH
* TOOLBOX
* LANGUAGES

MediaWiki:Sidebar

2026-05-21T20:53:32Z

Administrator:

* navigation
** https://przybylowicz.it|Home
** mainpage|PK Base
** specialpages-url|specialpages
* SEARCH
* TOOLBOX
* LANGUAGES

MediaWiki:Sidebar

2026-05-21T20:52:42Z

Administrator:

* navigation
** https://przybylowicz.it|Home
** mainpage|mainpage-description
** specialpages-url|specialpages
* SEARCH
* TOOLBOX
* LANGUAGES

MediaWiki:Sidebar

2026-05-21T20:51:24Z

Administrator:

* navigation
** mainpage|mainpage-description
** https://przybylowicz.it|Home
** specialpages-url|specialpages
* SEARCH
* TOOLBOX
* LANGUAGES

MediaWiki:Sidebar

2026-05-21T20:50:38Z

Strona główna

2026-05-21T20:30:53Z

Administrator:

'''My personal knowledge base'''

It is a collection of my knowledge resources and lessons learned from various IT tasks.

[[Specjalna:Kategorie|Pages are grouped by Categories]]

<kroki lang="blockdiag">blockdiag {
"Main page" -> Outerapi -> "REST/THYMELEAF";
"Main page" -> PKBase -> "Wiki Articles";
"Main page" -> Blog -> "Wordpress Posts";

"Main page" [color = "greenyellow"];
"Outerapi" [color = "pink"];
"PKBase" [color = "pink"];
"Blog" [color = "pink"];
"Wiki Articles" [color = "orange"];
"Wordpress Posts" [color = "orange"];
"REST/THYMELEAF" [color = "orange"];
}</kroki>[[Test Flows|Check other diagrams]]

== Getting started ==

* [[mediawikiwiki:Special:MyLanguage/Manual:Configuration_settings|Configuration settings list]]
* [[mediawikiwiki:Special:MyLanguage/Manual:FAQ|MediaWiki FAQ]]
* [https://lists.wikimedia.org/postorius/lists/mediawiki-announce.lists.wikimedia.org/ MediaWiki release mailing list]
* [[mediawikiwiki:Special:MyLanguage/Localisation#Translation_resources|Localise MediaWiki for your language]]
* [[mediawikiwiki:Special:MyLanguage/Manual:Combating_spam|Learn how to combat spam on your wiki]]

Consult the [[mediawikiwiki:Special:MyLanguage/Help:Contents|User's Guide]] for information on using the wiki software.
*

Gastro Integrator

2026-05-19T14:10:22Z

Administrator: 1 wersja

<kroki lang="blockdiag">blockdiag {
"restaumatic.com" -> "Gastro Integrator" -> "cromcabistro.pl";
"restaumatic.com" [color = "greenyellow"];
"Gastro Integrator" [color = "pink"];
"cromcabistro.pl" [color = "orange"];
}</kroki>

Main Page

2026-05-19T14:10:22Z

Administrator: 1 wersja

My personal knowledge base

It is a collection of my knowledge resources and lessons learned from various IT tasks.

[[Special:Categories|Pages are grouped by Categories]]

<kroki lang="blockdiag">blockdiag {
"Main page" -> Outerapi -> "REST/THYMELEAF";
"Main page" -> PKBase -> "Wiki Articles";
"Main page" -> Blog -> "Wordpress Posts";

"Main page" [color = "greenyellow"];
"Outerapi" [color = "pink"];
"PKBase" [color = "pink"];
"Blog" [color = "pink"];
"Wiki Articles" [color = "orange"];
"Wordpress Posts" [color = "orange"];
"REST/THYMELEAF" [color = "orange"];
}</kroki>[[Test Flows|Check other diagrams]]

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/postorius/lists/mediawiki-announce.lists.wikimedia.org/ MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]

Consult the [[mediawikiwiki:Special:MyLanguage/Help:Contents|User's Guide]] for information on using the wiki software.

Feel free to visit my blog

2026-05-19T14:10:22Z

Administrator: 1 wersja

I invite you to visit my [http://192.168.179.10/blog blog].

All parts of whole service are integrated autenthicated.

Please use OpenId Connect connection if available.
[[Category:Hosting]]

Nginx

2026-05-19T14:10:22Z

Administrator: 1 wersja

Nginx [engine x] to serwer proxy, reverse proxy, mail proxy server. Może też pełnić rolę ogólnego serwera proxy TCP/UDP (jeszcze nie wiem co to znaczy).
Dla mnie wartością jest to, że na jednym porcie https/443 mogę wystawiać rożne aplikacje http (pracujące na rożnych portach), może także wystawiać swój kontent bez proxowania:
* /cool-site https://serwer.com
* http/8080 https://serwer.com/app1
* http/7070 https://serwer.com/app2
* Do tego wspólnego portu, https/443, można dodać certyfikat SSL, co daje możliwość uruchomia wielu aplikacji i usług typu REST na jednym certyfikacie i jednym hoście (domenie).
Przykładem jest ta wiki, wystawiona na Nginxie, który działa na porcie https/443 i jednocześnie proxuje na niego aplikację Java Spring Boot z portu http/8080, zapewniając obu aplikacjom bezpieczne połączenie.
[[Category:Hosting]]

Cloud infrastructure costs

2026-05-19T14:10:21Z

Administrator: 1 wersja

AZURE: An App Service with Elastic Azure Database Server for MySQL costs about 250 PLN (50 EUR) / month, for hosting an app that basically did nothing, perhaps a cache could reduce costs.

ASAP switched to nazwa.pl, 25 PLN per month for smallest VPC hosting program, but this case also need some linux experience.

Stay nazwa.pl client with 20 % discount by my [https://www.nazwa.pl/pp/am86-7446-9653 partnership link], followers can be empowerment with my free, limited support. Details are preparing.
[[Category:Hosting]]

Hosting resources on the Internet

2026-05-19T14:10:20Z

Administrator: 1 wersja

[[Category:Hosting]]
Czasami zachodzi potrzeba przeniesienia się z tym co udostępniamy w internecie do innego dostawcy usług hostingowych. Warto na ten, często awaryjny, krok być przygotowanym aby móc go przeprowadzić szybko i sprawnie. Najlepiej sobie wszystko wcześniej zaplanować, najpierw zinwentaryzuję co już zbudowałem:
{| class="wikitable"
|+
!
!metoda pozyskania
!pochodzenie
|-
|Zmiana adresu w DNS
|ręcznie
|<nowiki>https://home.pl</nowiki>
|-
|Aplikacja Java Spring Boot, wystawia się http:7070
|build from git
|https://gitlab.com/java-padawans/microservices.git
|-
|Open JDK-21
|install on OS
|sudo apt-get install openjdk-21-jre-headless
|-
|MySQL server v8
|install on OS
|sudo apt install mysql-server
|-
|Nginx - proxy 443>7070, www
|install on OS
|sudo apt install nginx-light
sudo apt-get install nginx-extras
|-
|Cool Nginx error pages
Konfiguracja Nginx
w szczególności Wikimedia config
|backup
|/srv/http/default
/etc/nginx, /etc/nginx/sites-available/default
/etc/nginx/snippets/mediawiki.conf
|-
|Folder www wikimedii
|backup
|/var/www/html/wikimedia
|-
|Certyfikaty SSL
|backup
|/home/outerapis/ssl/
zadbać o bezpieczeństwo klucza prywatnego
|-
|Skrypty MySQL Database recovery
|backup
|/home/outerapis/sqls
microservices/outerapis/src/main/resources/create.sql
microservices/outerapis/src/main/resources/data.sql
|-
|sshd config
|backup
|/etc/ssh/sshd_config
|-
|sudo config
|backup
|/etc/sudoers
|-
|Skrypt dla usługi systemd
|backup
|/etc/systemd/system/outerapis.service
/etc/default/outerapis
|-
|Domyślne ustawienia dla polecenia less
|backup
|/etc/default/less
|-
|Skrypt dla usługi logrotate
|backup
|/etc/logrotate.d/outerapis
|-
|Skrypt MySQL Database backup
|backup
|export, zip
|-
|Odtworzenie konfiguracji: skrypty / ręcznie.
Co jest robione ręcznie musi być udokumentowane na wiki, wraz z uzasadnieniem dlaczego nie można danego kroku zautomatyzować.
|backup, wiki
|user for adm, user for app
ssh keys
|}
''Ten dokument powinien być wydrukowany i przechowywany w odpowiednim skoroszycie w kategorii RECOVERY, lub w postaci elektronicznej, poza file systemem dostępnym w ramach hostingu. '''Przy braku dostępności usługi hostingowej, zasoby tej wikipedii nie będą dostępne.'''''

== Log rorate ==
<syntaxhighlight lang="bash" line="1">
$ cat /etc/logrotate.d/outerapis
/var/log/outerapis/*.log {
daily
rotate 7
maxsize 10M
missingok
compress
delaycompress
notifempty
}
</syntaxhighlight>

== Nginx proxy ==
Podstawowa konfiguracja<syntaxhighlight lang="bash" line="1">
location / {
proxy_pass http://localhost:7070;
proxy_http_version 1.1;
#proxy_redirect off;
proxy_read_timeout 60s;
include /etc/nginx/proxy_params;
proxy_redirect http:// https://;
}
</syntaxhighlight>
[[Nginx|Więcej o konfigurowaniu Nginx]]

Hibernate

2026-05-19T14:09:57Z

Administrator: 1 wersja

#REDIRECT [[Main Page]]
''Pod żadnym pozorem nie uzurpuję sobie praw do poniższych treści. To cenna wiedza do której czesto sięgam i o którą czasem jestem pytany, wiec sobie troche to ułatwiłem opracowując w moim rodzimym języku treści dostępne w oryginale na stronie oficjalnej dokumentacji [https://docs.hibernate.org/orm/7.3/userguide Hibernate.org 7.3], starałem sie zapewnić dobrą jakość przekładu.''

==== 3.8 Asocjacje ====
Chcesz zapanować nad relacjami? Używaj Hibernate :)

====== @ManyToOne ======
Najczęstsze skojarzenie, posiadające bezpośredni odpowiednik w relacyjnej bazie danych, a więc adnotacja ta ustanawia relację między podmiotem potomnym a rodzicem. Każdy podmiot ma swój własny cykl życia. Po ustawieniu skojarzenia '''@ManyToOne''', Hibernate dodaje kolumnę powiązanego klucza obcego.<syntaxhighlight lang="java">
Person person = new Person();
entityManager.persist( person );

Phone phone = new Phone( "123-456-7890" );
phone.setPerson( person );
entityManager.persist( phone );

entityManager.flush();
phone.setPerson( null );
</syntaxhighlight><syntaxhighlight lang="sql">
INSERT INTO Person ( id )
VALUES ( 1 )

INSERT INTO Phone ( number, person_id, id )
VALUES ( '123-456-7890', 1, 2 )

UPDATE Phone
SET number = '123-456-7890',
person_id = NULL
WHERE id = 2
</syntaxhighlight>

===== @OneToMany =====
Łączy podmiot nadrzędny z jednym lub większą liczbą podmiotów potomnych. Jeśli '''@OneToMany''' nie ma odwrotnego skojarzenia @ManyToOne po stronie dziecka, to skojarzenie '''@OneToMany''' jest jednokierunkowe. Jeśli istnieje @ManyToOne po stronie dziecka, skojarzenie '''@OneToMany''' jest dwukierunkowe, a twórca aplikacji może poruszać się po tej relacji z obu stron.

====== Jednokierunkowy @OneToMany ======
W jednokierunkowym skojarzeniu '''@OneToMany''', Hibernate tworzy połączenia między dwoma obiektami.
<syntaxhighlight lang="java">
@Entity(name = "Person")
public static class Person {

@Id
@GeneratedValue
private Long id;

@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
private List<Phone> phones = new ArrayList<>();

//Getters and setters are omitted for brevity

}

@Entity(name = "Phone")
public static class Phone {

@Id
@GeneratedValue
private Long id;

@Column(name = "`number`")
private String number;

//Getters and setters are omitted for brevity

}
</syntaxhighlight><syntaxhighlight lang="sql">
CREATE TABLE Person (
id BIGINT NOT NULL ,
PRIMARY KEY ( id )
)

CREATE TABLE Person_Phone (
Person_id BIGINT NOT NULL ,
phones_id BIGINT NOT NULL
)

CREATE TABLE Phone (
id BIGINT NOT NULL ,
number VARCHAR(255) ,
PRIMARY KEY ( id )
)

ALTER TABLE Person_Phone
ADD CONSTRAINT UK_9uhc5itwc9h5gcng944pcaslf
UNIQUE (phones_id)

ALTER TABLE Person_Phone
ADD CONSTRAINT FKr38us2n8g5p9rj0b494sd3391
FOREIGN KEY (phones_id) REFERENCES Phone

ALTER TABLE Person_Phone
ADD CONSTRAINT FK2ex4e4p7w1cj310kg2woisjl2
FOREIGN KEY (Person_id) REFERENCES Person
</syntaxhighlight>
Asocjacja '''@OneToMany''' jest z definicji asocjacją nadrzędną, niezależnie od tego, czy jest jedno, czy dwukierunkowa. Tylko strona nadrzędna asocjacji ma sens, aby kaskadować przejścia stanu encji do jej elementów podrzędnych.
<syntaxhighlight lang="java">
Person person = new Person();
Phone phone1 = new Phone( "123-456-7890" );
Phone phone2 = new Phone( "321-654-0987" );

person.getPhones().add( phone1 );
person.getPhones().add( phone2 );
entityManager.persist( person );
entityManager.flush();

person.getPhones().remove( phone1 );
</syntaxhighlight><syntaxhighlight lang="sql">
INSERT INTO Person
( id )
VALUES ( 1 )

INSERT INTO Phone
( number, id )
VALUES ( '123-456-7890', 2 )

INSERT INTO Phone
( number, id )
VALUES ( '321-654-0987', 3 )

INSERT INTO Person_Phone
( Person_id, phones_id )
VALUES ( 1, 2 )

INSERT INTO Person_Phone
( Person_id, phones_id )
VALUES ( 1, 3 )

DELETE FROM Person_Phone
WHERE Person_id = 1

INSERT INTO Person_Phone
( Person_id, phones_id )
VALUES ( 1, 3 )

DELETE FROM Phone
WHERE id = 2
</syntaxhighlight>
Podczas utrwalania encji Person, kaskada rozpropaguje operację utrwalania również do bazowych elementów potomnych Phone. Po usunięciu elementu Phone z kolekcji phones, wiersz skojarzenia jest usuwany z tabeli linków, a atrybut '''orphanRemoval''' również spowoduje usunięcie elementu Phone.
Jednokierunkowe powiązania nie są zbyt wydajne w przypadku usuwania encji podrzędnych. W powyższym przykładzie, po opróżnieniu kontekstu utrwalania, Hibernate usuwa wszystkie wiersze bazy danych z tabeli linków (np. Person_Phone), które są powiązane z nadrzędną encją Person, i ponownie wstawia te, które nadal znajdują się w kolekcji '''@OneToMany'''. Z drugiej strony, dwukierunkowe powiązanie '''@OneToMany''' jest znacznie wydajniejsze, ponieważ encja podrzędna kontroluje powiązanie.

====== Dwukierunkowe powiązanie @OneToMany ======
Dwukierunkowe powiązanie '''@OneToMany''' wymaga również powiązania @ManyToOne po stronie potomnej. Chociaż model domeny udostępnia dwie strony do nawigacji po tym powiązaniu, w tle relacyjna baza danych ma tylko jeden klucz obcy dla tej relacji.

Każde powiązanie dwukierunkowe musi mieć tylko jedną stronę właścicielską (stronę potomną), a druga jest określana jako strona odwrotna (lub strona '''mappedBy''').
<syntaxhighlight lang="java">
@Entity(name = "Person")
public static class Person {

@Id
@GeneratedValue
private Long id;

@OneToMany(mappedBy = "person", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Phone> phones = new ArrayList<>();

//Getters and setters are omitted for brevity

public void addPhone(Phone phone) {
phones.add( phone );
phone.setPerson( this );
}

public void removePhone(Phone phone) {
phones.remove( phone );
phone.setPerson( null );
}
}

@Entity(name = "Phone")
public static class Phone {

@Id
@GeneratedValue
private Long id;

@NaturalId
@Column(name = "`number`", unique = true)
private String number;

@ManyToOne
private Person person;

//Getters and setters are omitted for brevity

@Override
public boolean equals(Object o) {
if ( this == o ) {
return true;
}
if ( o == null || getClass() != o.getClass() ) {
return false;
}
Phone phone = (Phone) o;
return Objects.equals( number, phone.number );
}

@Override
public int hashCode() {
return Objects.hash( number );
}
}
</syntaxhighlight><syntaxhighlight lang="sql">
CREATE TABLE Person (
id BIGINT NOT NULL ,
PRIMARY KEY ( id )
)

CREATE TABLE Phone (
id BIGINT NOT NULL ,
number VARCHAR(255) ,
person_id BIGINT ,
PRIMARY KEY ( id )
)

ALTER TABLE Phone
ADD CONSTRAINT UK_l329ab0g4c1t78onljnxmbnp6
UNIQUE (number)

ALTER TABLE Phone
ADD CONSTRAINT FKmw13yfsjypiiq0i1osdkaeqpg
FOREIGN KEY (person_id) REFERENCES Person
</syntaxhighlight>
Za każdym razem, gdy tworzone jest skojarzenie dwukierunkowe, programista aplikacji musi upewnić się, że obie strony są zawsze zsynchronizowane. Metody '''addPhone()''' i '''removePhone()''' to metody narzędziowe, które synchronizują obie strony za każdym razem, gdy dodawany lub usuwany jest element podrzędny.
Ponieważ klasa Phone ma kolumnę '''@NaturalId''' (numer telefonu jest unikalny), '''equals()''' i '''hashCode()''' mogą korzystać z tej właściwości, a logika '''removePhone()''' zostaje zredukowana do metody '''remove()''' z Java Collection.

W przeciwieństwie do jednokierunkowego '''@OneToMany''', dwukierunkowe skojarzenie jest znacznie bardziej wydajne w zarządzaniu stanem trwałości kolekcji. Każde usunięcie elementu wymaga tylko jednej aktualizacji (w której kolumna klucza obcego jest ustawiana na NULL), a jeśli cykl życia encji potomnej jest powiązany z jej elementem nadrzędnym, tak że encja potomna nie może istnieć bez niego, wówczas możemy opatrzyć skojarzenie adnotacją atrybutu orphanRemoval, a usunięcie encji potomnej spowoduje również instrukcję delete dla wiersza tabeli potomnej.

===== @OneToOne =====
Asocjacja '''@OneToOne''' może być jednokierunkowa lub dwukierunkowa. Asocjacja jednokierunkowa jest zgodna z semantyką klucza obcego relacyjnej bazy danych, a właścicielem relacji jest strona klienta. Asocjacja dwukierunkowa zawiera również stronę nadrzędną '''mappedBy''' '''@OneToOne'''.

====== Jednokierunkowy @OneToOne ======
<syntaxhighlight lang="java">
@Entity(name = "Phone")
public static class Phone {

@Id
@GeneratedValue
private Long id;

@Column(name = "`number`")
private String number;

@OneToOne
@JoinColumn(name = "details_id")
private PhoneDetails details;

//Getters and setters are omitted for brevity

}

@Entity(name = "PhoneDetails")
public static class PhoneDetails {

@Id
@GeneratedValue
private Long id;

private String provider;

private String technology;

//Getters and setters are omitted for brevity

}
</syntaxhighlight><syntaxhighlight lang="sql">
CREATE TABLE Phone (
id BIGINT NOT NULL ,
number VARCHAR(255) ,
details_id BIGINT ,
PRIMARY KEY ( id )
)

CREATE TABLE PhoneDetails (
id BIGINT NOT NULL ,
provider VARCHAR(255) ,
technology VARCHAR(255) ,
PRIMARY KEY ( id )
)

ALTER TABLE Phone
ADD CONSTRAINT FKnoj7cj83ppfqbnvqqa5kolub7
FOREIGN KEY (details_id) REFERENCES PhoneDetails
</syntaxhighlight>Z punktu widzenia relacyjnej bazy danych, schemat bazowy jest identyczny z jednokierunkowym skojarzeniem '''@ManyToOne''', ponieważ strona klienta kontroluje relację w oparciu o kolumnę klucza obcego. Nietypowe jest jednak traktowanie telefonu jako strony klienta, a szczegółów telefonu jako strony nadrzędnej, ponieważ szczegóły nie mogą istnieć bez faktycznego telefonu. Znacznie bardziej naturalnym odwzorowaniem byłoby umieszczenie telefonu jako strony nadrzędnej, a zatem umieszczenie klucza obcego w tabeli szczegółów telefonu.

====== Dwukierunkowy @OneToOne ======
<syntaxhighlight lang="java">
@Entity(name = "Phone")
public static class Phone {

@Id
@GeneratedValue
private Long id;

@Column(name = "`number`")
private String number;

@OneToOne(
mappedBy = "phone",
cascade = CascadeType.ALL,
orphanRemoval = true,
fetch = FetchType.LAZY
)
private PhoneDetails details;

//Getters and setters are omitted for brevity

public void addDetails(PhoneDetails details) {
details.setPhone( this );
this.details = details;
}

public void removeDetails() {
if ( details != null ) {
details.setPhone( null );
this.details = null;
}
}
}

@Entity(name = "PhoneDetails")
public static class PhoneDetails {

@Id
@GeneratedValue
private Long id;

private String provider;

private String technology;

@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "phone_id")
private Phone phone;

//Getters and setters are omitted for brevity

}
</syntaxhighlight><syntaxhighlight lang="sql">
CREATE TABLE Phone (
id BIGINT NOT NULL ,
number VARCHAR(255) ,
PRIMARY KEY ( id )
)

CREATE TABLE PhoneDetails (
id BIGINT NOT NULL ,
provider VARCHAR(255) ,
technology VARCHAR(255) ,
phone_id BIGINT ,
PRIMARY KEY ( id )
)

ALTER TABLE PhoneDetails
ADD CONSTRAINT FKeotuev8ja8v0sdh29dynqj05p
FOREIGN KEY (phone_id) REFERENCES Phone
</syntaxhighlight>Tym razem właścicielem skojarzenia jest PhoneDetails i, jak w przypadku każdego dwukierunkowego skojarzenia, strona nadrzędna może propagować swój cykl życia do strony podrzędnej poprzez kaskadowanie.<syntaxhighlight lang="java">
Phone phone = new Phone( "123-456-7890" );
PhoneDetails details = new PhoneDetails( "T-Mobile", "GSM" );

phone.addDetails( details );
entityManager.persist( phone );
</syntaxhighlight><syntaxhighlight lang="sql">
INSERT INTO Phone ( number, id )
VALUES ( '123-456-7890', 1 )

INSERT INTO PhoneDetails ( phone_id, provider, technology, id )
VALUES ( 1, 'T-Mobile', 'GSM', 2 )
</syntaxhighlight>Podczas korzystania z dwukierunkowego skojarzenia '''@OneToOne''', Hibernate wymusza ograniczenie unikalności podczas pobierania strony potomnej. Jeśli z tym samym obiektem nadrzędnym powiązanych jest więcej niż jeden obiekt potomny, Hibernate zgłosi wyjątek org.hibernate.exception.ConstraintViolationException. Np, podczas dodawania kolejnego obiektu PhoneDetails, Hibernate weryfikuje ograniczenie unikalności podczas ponownego ładowania obiektu Phone.<syntaxhighlight lang="java">
PhoneDetails otherDetails = new PhoneDetails( "T-Mobile", "CDMA" );
otherDetails.setPhone( phone );
entityManager.persist( otherDetails );
entityManager.flush();
entityManager.clear();

//throws jakarta.persistence.PersistenceException: org.hibernate.HibernateException: More than one row with the given identifier was found: 1
phone = entityManager.find( Phone.class, phone.getId() );
</syntaxhighlight>

====== Dwukierunkowe, leniwe skojarzenie @OneToOne ======
Chociaż można dodać adnotację do skojarzenia po stronie nadrzędnej, aby było ono pobierane leniwie, Hibernate nie może zrealizować tego żądania, ponieważ nie wie, czy skojarzenie jest puste, czy nie.

Jedynym sposobem na sprawdzenie, czy po stronie podrzędnej istnieje skojarzenie, jest pobranie skojarzenia potomnego za pomocą zapytania pomocniczego. Ponieważ może to prowadzić do problemów z zapytaniami N+1, znacznie bardziej efektywne jest użycie jednokierunkowych skojarzeń '''@OneToOne''' z adnotacją '''@MapsId'''.

Jeśli jednak naprawdę potrzebujesz użyć skojarzenia dwukierunkowego i chcesz mieć pewność, że zawsze będzie ono pobierane leniwie, musisz włączyć rozszerzenie bajtkodu inicjalizacji stanu leniwego.<syntaxhighlight lang="java">
@Entity(name = "Phone")
public static class Phone {

@Id
@GeneratedValue
private Long id;

@Column(name = "`number`")
private String number;

@OneToOne(
mappedBy = "phone",
cascade = CascadeType.ALL,
orphanRemoval = true,
fetch = FetchType.LAZY
)
private PhoneDetails details;

//Getters and setters are omitted for brevity

public void addDetails(PhoneDetails details) {
details.setPhone( this );
this.details = details;
}

public void removeDetails() {
if ( details != null ) {
details.setPhone( null );
this.details = null;
}
}
}

@Entity(name = "PhoneDetails")
public static class PhoneDetails {

@Id
@GeneratedValue
private Long id;

private String provider;

private String technology;

@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "phone_id")
private Phone phone;

//Getters and setters are omitted for brevity

}
</syntaxhighlight>

===== @ManyToMany =====
Asocjacja '''@ManyToMany''' wymaga tabeli linków, która łączy dwie encje. Podobnie jak asocjacja '''@OneToMany''', '''@ManyToMany''' może być jednokierunkowa lub dwukierunkowa.

====== Jednokierunkowy @ManyToMany ======
<syntaxhighlight lang="java">
@Entity(name = "Person")
public static class Person {

@Id
@GeneratedValue
private Long id;

@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
private List<Address> addresses = new ArrayList<>();

//Getters and setters are omitted for brevity

}

@Entity(name = "Address")
public static class Address {

@Id
@GeneratedValue
private Long id;

private String street;

@Column(name = "`number`")
private String number;

//Getters and setters are omitted for brevity

}
</syntaxhighlight><syntaxhighlight lang="sql">
CREATE TABLE Address (
id BIGINT NOT NULL ,
number VARCHAR(255) ,
street VARCHAR(255) ,
PRIMARY KEY ( id )
)

CREATE TABLE Person (
id BIGINT NOT NULL ,
PRIMARY KEY ( id )
)

CREATE TABLE Person_Address (
Person_id BIGINT NOT NULL ,
addresses_id BIGINT NOT NULL
)

ALTER TABLE Person_Address
ADD CONSTRAINT FKm7j0bnabh2yr0pe99il1d066u
FOREIGN KEY (addresses_id) REFERENCES Address

ALTER TABLE Person_Address
ADD CONSTRAINT FKba7rc9qe2vh44u93u0p2auwti
FOREIGN KEY (Person_id) REFERENCES Person
</syntaxhighlight>Podobnie jak w przypadku jednokierunkowych skojarzeń @OneToMany, tabela linków jest kontrolowana przez stronę posiadającą.

Gdy encja jest usuwana z kolekcji '''@ManyToMany''', Hibernate po prostu usuwa rekord łączenia z tabeli linków. Niestety, operacja ta wymaga usunięcia wszystkich wpisów powiązanych z danym elementem nadrzędnym i ponownego utworzenia tych, które są wymienione w bieżącym kontekście utwalania.<syntaxhighlight lang="java">
Person person1 = new Person();
Person person2 = new Person();

Address address1 = new Address( "12th Avenue", "12A" );
Address address2 = new Address( "18th Avenue", "18B" );

person1.getAddresses().add( address1 );
person1.getAddresses().add( address2 );

person2.getAddresses().add( address1 );

entityManager.persist( person1 );
entityManager.persist( person2 );

entityManager.flush();

person1.getAddresses().remove( address1 );
</syntaxhighlight><syntaxhighlight lang="sql">
INSERT INTO Person ( id )
VALUES ( 1 )

INSERT INTO Address ( number, street, id )
VALUES ( '12A', '12th Avenue', 2 )

INSERT INTO Address ( number, street, id )
VALUES ( '18B', '18th Avenue', 3 )

INSERT INTO Person ( id )
VALUES ( 4 )

INSERT INTO Person_Address ( Person_id, addresses_id )
VALUES ( 1, 2 )
INSERT INTO Person_Address ( Person_id, addresses_id )
VALUES ( 1, 3 )
INSERT INTO Person_Address ( Person_id, addresses_id )
VALUES ( 4, 2 )

DELETE FROM Person_Address
WHERE Person_id = 1

INSERT INTO Person_Address ( Person_id, addresses_id )
VALUES ( 1, 3 )
</syntaxhighlight>
W przypadku asocjacji '''@ManyToMany''' kaskadowanie przejścia stanu encji '''REMOVE''' nie ma sensu, ponieważ będzie ono propagowane poza tabelę linków. Ponieważ do drugiej strony mogą odwoływać się inne encje po stronie nadrzędnej, automatyczne usunięcie może zakończyć się wyjątkiem '''ConstraintViolationException'''.
Na przykład, gdyby zdefiniowano '''@ManyToMany(cascade = CascadeType.ALL)''' i pierwsza osoba zostałaby usunięta, Hibernate zgłosiłby wyjątek, ponieważ inna osoba nadal jest powiązana z usuwanym adresem.
<blockquote><syntaxhighlight lang="java">
Person person1 = entityManager.find(Person.class, personId);
entityManager.remove(person1);

Caused by: jakarta.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: could not execute statement
Caused by: org.hibernate.exception.ConstraintViolationException: could not execute statement
Caused by: java.sql.SQLIntegrityConstraintViolationException: integrity constraint violation: foreign key no action; FKM7J0BNABH2YR0PE99IL1D066U table: PERSON_ADDRESS
</syntaxhighlight></blockquote>Poprzez proste usunięcie strony nadrzędnej Hibernate może bezpiecznie usunąć powiązane rekordy łączy, jak widać w poniższym przykładzie:<syntaxhighlight lang="java">
Person person1 = entityManager.find( Person.class, personId );
entityManager.remove( person1 );

</syntaxhighlight><syntaxhighlight lang="sql">
DELETE FROM Person_Address
WHERE Person_id = 1

DELETE FROM Person
WHERE id = 1
</syntaxhighlight>

====== Dwukierunkowy @ManyToMany ======
Dwukierunkowe skojarzenie '''@ManyToMany''' ma stronę „właściciel” i „mappedBy”. Aby zachować synchronizację między obiema stronami, warto zapewnić metody pomocnicze do dodawania lub usuwania encji podrzędnych.<syntaxhighlight lang="java">
@Entity(name = "Person")
public static class Person {

@Id
@GeneratedValue
private Long id;

@NaturalId
private String registrationNumber;

@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
private List<Address> addresses = new ArrayList<>();

//Getters and setters are omitted for brevity

public void addAddress(Address address) {
addresses.add(address);
address.getOwners().add(this);
}

public void removeAddress(Address address) {
addresses.remove(address);
address.getOwners().remove(this);
}

@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Person person = (Person) o;
return Objects.equals(registrationNumber, person.registrationNumber);
}

@Override
public int hashCode() {
return Objects.hash(registrationNumber);
}
}

@Entity(name = "Address")
public static class Address {

@Id
@GeneratedValue
private Long id;

private String street;

@Column(name = "`number`")
private String number;

private String postalCode;

@ManyToMany(mappedBy = "addresses")
private List<Person> owners = new ArrayList<>();

//Getters and setters are omitted for brevity

@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Address address = (Address) o;
return Objects.equals(street, address.street) &&
Objects.equals(number, address.number) &&
Objects.equals(postalCode, address.postalCode);
}

@Override
public int hashCode() {
return Objects.hash(street, number, postalCode);
}
}
</syntaxhighlight><syntaxhighlight lang="sql">
CREATE TABLE Address (
id BIGINT NOT NULL ,
number VARCHAR(255) ,
postalCode VARCHAR(255) ,
street VARCHAR(255) ,
PRIMARY KEY ( id )
)

CREATE TABLE Person (
id BIGINT NOT NULL ,
registrationNumber VARCHAR(255) ,
PRIMARY KEY ( id )
)

CREATE TABLE Person_Address (
owners_id BIGINT NOT NULL ,
addresses_id BIGINT NOT NULL
)

ALTER TABLE Person
ADD CONSTRAINT UK_23enodonj49jm8uwec4i7y37f
UNIQUE (registrationNumber)

ALTER TABLE Person_Address
ADD CONSTRAINT FKm7j0bnabh2yr0pe99il1d066u
FOREIGN KEY (addresses_id) REFERENCES Address

ALTER TABLE Person_Address
ADD CONSTRAINT FKbn86l24gmxdv2vmekayqcsgup
FOREIGN KEY (owners_id) REFERENCES Person
</syntaxhighlight>

Dzięki zastosowaniu metod pomocniczych zarządzanie synchronizacją może zostać uproszczone, co widać w poniższym przykładzie:<syntaxhighlight lang="java">
Person person1 = new Person("ABC-123");
Person person2 = new Person("DEF-456");

Address address1 = new Address("12th Avenue", "12A", "4005A");
Address address2 = new Address("18th Avenue", "18B", "4007B");

person1.addAddress(address1);
person1.addAddress(address2);

person2.addAddress(address1);

entityManager.persist(person1);
entityManager.persist(person2);

entityManager.flush();

person1.removeAddress(address1);
</syntaxhighlight><syntaxhighlight lang="sql">
INSERT INTO Person ( registrationNumber, id )
VALUES ( 'ABC-123', 1 )

INSERT INTO Address ( number, postalCode, street, id )
VALUES ( '12A', '4005A', '12th Avenue', 2 )

INSERT INTO Address ( number, postalCode, street, id )
VALUES ( '18B', '4007B', '18th Avenue', 3 )

INSERT INTO Person ( registrationNumber, id )
VALUES ( 'DEF-456', 4 )

INSERT INTO Person_Address ( owners_id, addresses_id )
VALUES ( 1, 2 )

INSERT INTO Person_Address ( owners_id, addresses_id )
VALUES ( 1, 3 )

INSERT INTO Person_Address ( owners_id, addresses_id )
VALUES ( 4, 2 )

DELETE FROM Person_Address
WHERE owners_id = 1

INSERT INTO Person_Address ( owners_id, addresses_id )
VALUES ( 1, 3 )
</syntaxhighlight>Jeśli dwukierunkowe skojarzenie @OneToMany działa lepiej podczas usuwania lub zmiany kolejności elementów potomnych, relacja '''@ManyToMany''' nie może skorzystać z takiej optymalizacji, ponieważ klucz obcy nie ma nad nią kontroli. Aby obejść to ograniczenie, tabela linków musi być bezpośrednio ujawniona, a skojarzenie '''@ManyToMany''' musi zostać podzielone na dwie dwukierunkowe relacje @OneToMany.

===== Dwukierunkowa komunikacja wiele-do-wielu z jednostką łącza =====
Najbardziej naturalne skojarzenie @ManyToMany opiera się na tej samej logice, co schemat bazy danych, a tabela łączy ma skojarzoną encję, która kontroluje relację dla obu stron, które mają zostać połączone.<syntaxhighlight lang="java">
@Entity(name = "Person")
public static class Person implements Serializable {

@Id
@GeneratedValue
private Long id;

@NaturalId
private String registrationNumber;

@OneToMany(
mappedBy = "person",
cascade = CascadeType.ALL,
orphanRemoval = true
)
private List<PersonAddress> addresses = new ArrayList<>();

//Getters and setters are omitted for brevity

public void addAddress(Address address) {
PersonAddress personAddress = new PersonAddress( this, address );
addresses.add( personAddress );
address.getOwners().add( personAddress );
}

public void removeAddress(Address address) {
PersonAddress personAddress = new PersonAddress( this, address );
address.getOwners().remove( personAddress );
addresses.remove( personAddress );
personAddress.setPerson( null );
personAddress.setAddress( null );
}

@Override
public boolean equals(Object o) {
if ( this == o ) {
return true;
}
if ( o == null || getClass() != o.getClass() ) {
return false;
}
Person person = (Person) o;
return Objects.equals( registrationNumber, person.registrationNumber );
}

@Override
public int hashCode() {
return Objects.hash( registrationNumber );
}
}

@Entity(name = "PersonAddress")
public static class PersonAddress implements Serializable {

@Id
@ManyToOne
private Person person;

@Id
@ManyToOne
private Address address;

//Getters and setters are omitted for brevity

@Override
public boolean equals(Object o) {
if ( this == o ) {
return true;
}
if ( o == null || getClass() != o.getClass() ) {
return false;
}
PersonAddress that = (PersonAddress) o;
return Objects.equals( person, that.person ) &&
Objects.equals( address, that.address );
}

@Override
public int hashCode() {
return Objects.hash( person, address );
}
}

@Entity(name = "Address")
public static class Address implements Serializable {

@Id
@GeneratedValue
private Long id;

private String street;

@Column(name = "`number`")
private String number;

private String postalCode;

@OneToMany(
mappedBy = "address",
cascade = CascadeType.ALL,
orphanRemoval = true
)
private List<PersonAddress> owners = new ArrayList<>();

//Getters and setters are omitted for brevity

@Override
public boolean equals(Object o) {
if ( this == o ) {
return true;
}
if ( o == null || getClass() != o.getClass() ) {
return false;
}
Address address = (Address) o;
return Objects.equals( street, address.street ) &&
Objects.equals( number, address.number ) &&
Objects.equals( postalCode, address.postalCode );
}

@Override
public int hashCode() {
return Objects.hash( street, number, postalCode );
}
}
</syntaxhighlight><syntaxhighlight lang="sql">
CREATE TABLE Address (
id BIGINT NOT NULL ,
number VARCHAR(255) ,
postalCode VARCHAR(255) ,
street VARCHAR(255) ,
PRIMARY KEY ( id )
)

CREATE TABLE Person (
id BIGINT NOT NULL ,
registrationNumber VARCHAR(255) ,
PRIMARY KEY ( id )
)

CREATE TABLE PersonAddress (
person_id BIGINT NOT NULL ,
address_id BIGINT NOT NULL ,
PRIMARY KEY ( person_id, address_id )
)

ALTER TABLE Person
ADD CONSTRAINT UK_23enodonj49jm8uwec4i7y37f
UNIQUE (registrationNumber)

ALTER TABLE PersonAddress
ADD CONSTRAINT FK8b3lru5fyej1aarjflamwghqq
FOREIGN KEY (person_id) REFERENCES Person

ALTER TABLE PersonAddress
ADD CONSTRAINT FK7p69mgialumhegyl4byrh65jk
FOREIGN KEY (address_id) REFERENCES Address
</syntaxhighlight>Zarówno Person, jak i Address mają stronę mappedBy @OneToMany, podczas gdy PersonAddress jest właścicielem osoby i adresu @ManyToOne. Ponieważ to mapowanie składa się z dwóch dwukierunkowych skojarzeń, metody pomocnicze są jeszcze bardziej istotne.
W powyższym przykładzie wykorzystano mapowanie specyficzne dla Hibernate dla encji łącza, ponieważ Jakarta Persistence nie pozwala na utworzenie identyfikatora złożonego z wielu powiązań @ManyToOne.
Aby uzyskać więcej informacji, zapoznaj się z sekcją dotyczącą identyfikatorów złożonych z powiązaniami.
Przejścia stanów encji są lepiej zarządzane niż w poprzednim przypadku dwukierunkowego '''@ManyToMany'''.<syntaxhighlight lang="java">
Person person1 = new Person( "ABC-123" );
Person person2 = new Person( "DEF-456" );

Address address1 = new Address( "12th Avenue", "12A", "4005A" );
Address address2 = new Address( "18th Avenue", "18B", "4007B" );

entityManager.persist( person1 );
entityManager.persist( person2 );

entityManager.persist( address1 );
entityManager.persist( address2 );

person1.addAddress( address1 );
person1.addAddress( address2 );

person2.addAddress( address1 );

entityManager.flush();

person1.removeAddress( address1 );
</syntaxhighlight><syntaxhighlight lang="sql">
INSERT INTO Person ( registrationNumber, id )
VALUES ( 'ABC-123', 1 )

INSERT INTO Person ( registrationNumber, id )
VALUES ( 'DEF-456', 2 )

INSERT INTO Address ( number, postalCode, street, id )
VALUES ( '12A', '4005A', '12th Avenue', 3 )

INSERT INTO Address ( number, postalCode, street, id )
VALUES ( '18B', '4007B', '18th Avenue', 4 )

INSERT INTO PersonAddress ( person_id, address_id )
VALUES ( 1, 3 )

INSERT INTO PersonAddress ( person_id, address_id )
VALUES ( 1, 4 )

INSERT INTO PersonAddress ( person_id, address_id )
VALUES ( 2, 3 )

DELETE FROM PersonAddress
WHERE person_id = 1 AND address_id = 3
</syntaxhighlight>

Wykonana zostaje tylko jedna instrukcja usunięcia, ponieważ tym razem powiązanie jest kontrolowane przez stronę '''@ManyToOne''', która musi jedynie monitorować stan podstawowej relacji klucza obcego, aby wywołać odpowiednią instrukcję DML.

===== @NotFound =====
W przypadku skojarzeń, które nie są wymuszane przez fizyczny klucz obcy, istnieje możliwość, że wartość klucza obcego inna niż null będzie wskazywać na nieistniejącą wartość w tabeli skojarzonej jednostki.
Zdecydowanie odradza się egzekwowanie stosowania fizycznych kluczy obcych na poziomie bazy danych.
Hibernate zapewnia obsługę takich modeli, korzystając z adnotacji @NotFound, która akceptuje wartość NotFoundAction wskazującą sposób zachowania się Hibernate w przypadku napotkania takich uszkodzonych kluczy obcych.

; EXCEPTION
: (default) Hibernate zuci wyjątek (<code>FetchNotFoundException</code>)
; IGNORE
: powiązanie będzie traktowane jako <code>null</code>

Zarówno @NotFound(IGNORE), jak i @NotFound(EXCEPTION) powodują, że Hibernate zakłada brak fizycznego klucza obcego.

Powiązania @ManyToOne i @OneToOne z adnotacją @NotFound są zawsze pobierane chciwie, nawet jeśli strategia pobierania jest ustawiona na FetchType.LAZY.
Jeśli aplikacja sama zarządza integralnością referencyjną i może zagwarantować brak uszkodzonych kluczy obcych, można zamiast tego użyć metody jakarta.persistence.ForeignKey(NO_CONSTRAINT). Zmusi to Hibernate do nieeksportowania fizycznych kluczy obcych, ale nadal będzie zachowywać się tak, jakby istniał, unikając wad @NotFound.
Biorąc pod uwagę następujące mapowania jednostek Miasto i Osoba:<syntaxhighlight lang="java">
@Entity(name = "Person")
@Table(name = "Person")
public static class Person {

@Id
private Integer id;
private String name;

@ManyToOne
@NotFound(action = NotFoundAction.IGNORE)
@JoinColumn(name = "city_fk", referencedColumnName = "id")
private City city;

//Getters and setters are omitted for brevity

}

@Entity(name = "City")
@Table(name = "City")
public static class City implements Serializable {

@Id
private Integer id;

private String name;

//Getters and setters are omitted for brevity

}
</syntaxhighlight>Jeżeli w naszej bazie danych znajdują się następujące podmioty:<syntaxhighlight lang="java">
City newYork = new City( 1, "New York" );
entityManager.persist( newYork );

Person person = new Person( 1, "John Doe", newYork );
entityManager.persist( person );
</syntaxhighlight>Podczas ładowania jednostki Person, Hibernate jest w stanie zlokalizować powiązaną jednostkę nadrzędną City:<syntaxhighlight lang="java">
Person person = entityManager.find( Person.class, 1 );
assertEquals( "New York", person.getCity().getName() );
</syntaxhighlight>Jeśli jednak złamiemy klucz obcy:<syntaxhighlight lang="java">
// the database allows this because there is no physical foreign-key
entityManager.createQuery( "delete City" ).executeUpdate();
</syntaxhighlight>Hibernate nie zgłosi żadnego wyjątku i przypisze wartość null do nieistniejącego odniesienia do encji City:<syntaxhighlight lang="java">
Person person = entityManager.find( Person.class, 1 );

assertNull( person.getCity(), "person.getCity() should be null" );
</syntaxhighlight>'''''@NotFound''''' wpływa również na sposób traktowania skojarzenia jako „dołączeń niejawnych” w HQL i kryteriach. W przypadku fizycznego klucza obcego, Hibernate może bezpiecznie założyć, że wartość w kolumnie (kolumnach) klucza obcego będzie zgodna z wartością w kolumnie (kolumnach) docelowej (docelowych), ponieważ baza danych upewnia się, że tak jest. Jednak '''''@NotFound''''' wymusza na Hibernate wykonanie dołączenia fizycznego dla dołączeń niejawnych, gdy w innym przypadku mogłoby to nie być konieczne.

Korzystając z modelu Person/City, rozważmy zapytanie z Person p, gdzie p.city.id ma wartość null.

Normalnie Hibernate nie potrzebowałby łączenia między tabelą Person a tabelą City, ponieważ fizyczny klucz obcy zapewniałby, że każda wartość różna od null w kolumnie Person.cityName miałaby odpowiadającą jej wartość różną od null w kolumnie City.name.

Jednak w przypadku mapowań '''''@NotFound''''' możliwe jest zerwanie skojarzenia, ponieważ nie ma fizycznego klucza obcego wymuszającego relację. Jak widać w sekcji „Zerwanie klucza obcego”, kolumna Person.cityName dla Johna Doe została zmieniona z „Nowy Jork” na „Atlantis”, mimo że w bazie danych nie ma miasta o nazwie „Atlantis”. Hibernate nie może zaufać wartości klucza obcego („Atlantis”), która ma odpowiadającą wartość docelową, więc musi łączyć się z tabelą City, aby rozwiązać wartość city.id.<syntaxhighlight lang="java">
final List<Person> nullResults = entityManager
.createQuery( "from Person p where p.city.id is null", Person.class )
.getResultList();
assertThat( nullResults ).isEmpty();

final List<Person> nonNullResults = entityManager
.createQuery( "from Person p where p.city.id is not null", Person.class )
.getResultList();
assertThat( nonNullResults ).isEmpty();
</syntaxhighlight>Żaden z wyników nie zawiera dopasowania dla „John Doe”, ponieważ sprzężenie wewnętrzne filtruje ten wiersz.

Hibernate obsługuje metodę odwołania się bezpośrednio do kolumny klucza (Person.cityName) w zapytaniu za pomocą specjalnej funkcji fk(..). Np.<syntaxhighlight lang="java">
final List<String> nullResults = entityManager
.createQuery( "select p.name from Person p where fk( p.city ) is null", String.class )
.getResultList();

assertThat( nullResults ).isEmpty();

final List<String> nonNullResults = entityManager
.createQuery( "select p.name from Person p left join p.city c where fk( c ) is not null", String.class )
.getResultList();
assertThat( nonNullResults ).hasSize( 1 );
assertThat( nonNullResults.get( 0 ) ).isEqualTo( "John Doe" );
</syntaxhighlight>

[[Category:Hibernate]]

Test Flows

2026-05-19T14:09:37Z

Administrator: 1 wersja

[[Category:Diagrams]]
[[File:Plantuml.png|thumb|[[PlantUML Diagram sample]]]]
[[File:Diagramipv4.png|thumb|[[Bytefield Diagram sample]]]]
[[File:Ditaadiagram.png|thumb|[[Ditaa Diagram sample]]]]
[[File:Erddiagram.png|thumb|[[Erd Diagram sample]]]]
[[File:Seqdiag.png|thumb|[[SeqDiag Diagram sample]]]]
[[File:Packet.png|thumb|[[Packetdiag sample]]]]
'''Mermaid Sequence diagram'''<kroki lang="mermaid">sequenceDiagram
participant Alice
participant Bob
Alice->John: Hello John, how are you?
loop Healthcheck
John->John: Fight against hypochondria
end
Note right of John: Rational thoughts prevail...
John-->Alice: Great!
John->Bob: How about you?
Bob-->John: Jolly good!</kroki>'''Mermaid Class diagrams'''<kroki lang="mermaid">classDiagram
note "From Duck till Zebra"
Animal <|-- Duck
note for Duck "can fly\ncan swim\ncan dive\ncan help in debugging"
Animal <|-- Fish
Animal <|-- Zebra
Animal : +int age
Animal : +String gender
Animal: +isMammal()
Animal: +mate()
class Duck{
+String beakColor
+swim()
+quack()
}
class Fish{
-int sizeInFeet
-canEat()
}
class Zebra{
+bool is_wild
+run()
}</kroki>'''Mermaid Classes and Annotations'''<kroki lang="mermaid">
classDiagram
class BankAccount
BankAccount : +String owner
BankAccount : +Bigdecimal balance
BankAccount : +deposit(amount)
BankAccount : +withdrawal(amount)
class Shape{
<<interface>>
noOfVertices
draw()
}
class Color{
<<enumeration>>
RED
BLUE
GREEN
WHITE
BLACK
}
</kroki>'''Mermaid, setting the direction of the diagram'''<kroki lang="mermaid">
classDiagram
direction RL
class Student {
-idCard : IdCard
}
class IdCard{
-id : int
-name : string
}
class Bike{
-id : int
-name : string
}
Student "1" --o "1" IdCard : carries
Student "1" --o "1" Bike : rides

</kroki>BPMN diagram<kroki lang="bpmn"><?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
typeLanguage="http://www.w3.org/2001/XMLSchema"
expressionLanguage="http://www.w3.org/1999/XPath"
targetNamespace="http://bpmn.io/schema/bpmn">
<process id="Process_1" isExecutable="false">
<startEvent id="StartEvent_1"/>
</process>
<bpmndi:BPMNDiagram id="BPMNDiagram_1">
<bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1">
<bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1">
<omgdc:Bounds x="152" y="102" width="36" height="36"/>
</bpmndi:BPMNShape>
</bpmndi:BPMNPlane>
</bpmndi:BPMNDiagram>
</definitions></kroki>Actdiag Diagram<kroki lang="actdiag">
actdiag {
write -> convert -> image

lane user {
label = "User"
write [label = "Writing reST"];
image [label = "Get diagram IMAGE"];
}
lane actdiag {
convert [label = "Convert reST to Image"];
}
}
</kroki>Rackdiag Diagram<kroki lang="rackdiag">
rackdiag {
// define height of rack
16U;

// define rack items
1: UPS [2U];
3: DB Server
4: Web Server
5: Web Server
6: Web Server
7: Load Balancer
8: L3 Switch
}

</kroki>

PlantUML Diagram sample

2026-05-19T14:09:35Z

Administrator: 1 wersja

[[Category:Diagrams]]

More inspiration on https://plantuml.com/
<kroki lang="plantuml">
@startwbs
skinparam monochrome true
* Business Process Modelling WBS
** Launch the project
*** Complete Stakeholder Research
*** Initial Implementation Plan
** Design phase
*** Model of AsIs Processes Completed
**** Model of AsIs Processes Completed1
**** Model of AsIs Processes Completed2
*** Measure AsIs performance metrics
*** Identify Quick Wins
** Complete innovate phase
@endwbs
</kroki><kroki lang="plantuml">
@startuml
participant Participant as Foo
actor Actor as Foo1
boundary Boundary as Foo2
control Control as Foo3
entity Entity as Foo4
database Database as Foo5
collections Collections as Foo6
queue Queue as Foo7
Foo -> Foo1 : To actor
Foo -> Foo2 : To boundary
Foo -> Foo3 : To control
Foo -> Foo4 : To entity
Foo -> Foo5 : To database
Foo -> Foo6 : To collections
Foo -> Foo7: To queue
@enduml
</kroki><kroki lang="plantuml">
@startuml
Alice -> Bob: Authentication Request

alt successful case

Bob -> Alice: Authentication Accepted

else some kind of failure

Bob -> Alice: Authentication Failure
group My own label
Alice -> Log : Log attack start
loop 1000 times
Alice -> Bob: DNS Attack
end
Alice -> Log : Log attack end
end

else Another type of failure

Bob -> Alice: Please repeat

end
@enduml

</kroki><kroki lang="plantuml">
[Edit online]

@startuml
left to right direction
actor Guest as g
package Professional {
actor Chef as c
actor "Food Critic" as fc
}
package Restaurant {
usecase "Eat Food" as UC1
usecase "Pay for Food" as UC2
usecase "Drink" as UC3
usecase "Review" as UC4
}
fc --> UC4
g --> UC1
g --> UC2
g --> UC3
@enduml

</kroki>[[Test Flows|back]]

SeqDiag Diagram sample

2026-05-19T14:09:35Z

Administrator: 1 wersja

[[Category:Diagrams]]
<kroki lang="seqdiag">
seqdiag {
browser -> webserver [label = "GET /index.html"];
browser <-- webserver;
browser -> webserver [label = "POST /blog/comment"];
webserver -> database [label = "INSERT comment"];
webserver <-- database;
browser <-- webserver;
}
</kroki>[[Test Flows|back]]

Erd Diagram sample

2026-05-19T14:09:35Z

Administrator: 1 wersja

[[Category:Diagrams]]
<kroki lang="erd">[Persons]
*name
email
mobile_num
pwd
+role_id
+address_id
+operator_id

[Operators]
*operator_id
name

[Roles]
*role_id
role_name

[Addresses]
*address_id
address1
address2
city
country
state
zip_code

Persons *--1 Operators
Persons *--1 Roles
Addresses 1--1 Persons</kroki>
[[Test Flows|back]]

Packetdiag sample

2026-05-19T14:09:35Z

Administrator: 1 wersja

[[Category:Diagrams]]
<kroki lang="packetdiag">
{
colwidth = 32
node_height = 72

0-15: Source Port
16-31: Destination Port
32-63: Sequence Number
64-95: Acknowledgment Number
96-99: Data Offset
100-105: Reserved
106: URG [rotate = 270]
107: ACK [rotate = 270]
108: PSH [rotate = 270]
109: RST [rotate = 270]
110: SYN [rotate = 270]
111: FIN [rotate = 270]
112-127: Window
128-143: Checksum
144-159: Urgent Pointer
160-191: (Options and Padding)
192-223: data [colheight = 3]
}

</kroki>[[Test Flows|Return]]

Ditaa Diagram sample

2026-05-19T14:09:35Z

Administrator: 1 wersja

[[Category:Diagrams]]
<kroki lang="ditaa">
+--------+ +-------+ +-------+ /-----------------\
| | --+ ditaa +--> | | | Things to do |
| Text | +-------+ |diagram| | cGRE |
|Document| |!magic!| | | | o Cut the grass |
| {d}| | | | | | o Buy jam |
+---+----+ +-------+ +-------+ | o Fix car |
: ^ | o Make website |
| Lots of work | \-----------------/
+-------------------------+

</kroki>[[Test Flows|Return]]

Bytefield Diagram sample

2026-05-19T14:09:35Z

Administrator: 1 wersja

[[Category:Diagrams]]
'''Number as bits'''<kroki lang="bytefield">
(def left-margin 1)
(def boxes-per-row 8)
(draw-column-headers {:labels (reverse (take 8 column-labels))})
(draw-related-boxes (number-as-bits 0xd3 8))

</kroki>'''Internet Protocol Version 4 header (RFC791)'''<kroki lang="bytefield">
(draw-column-headers)
(draw-box "Version" {:span 4})
(draw-box "IHL" {:span 4})
(draw-box "DSCP" {:span 6})
(draw-box "ECN" {:span 2})
(draw-box "Total length" {:span 16})
(draw-box "Identification" {:span 16})
(draw-box "Flags" {:span 3})
(draw-box "Fragment offset" {:span 13})
(draw-box "Time to live" {:span 8})
(draw-box "Protocol" {:span 8})
(draw-box "Header checksum" {:span 16})
(draw-box "Source IP address" [{:span 16}, :box-above])
(draw-box nil [{:span 16}, :box-below])

(draw-box "Destination IP address" [{:span 16}, :box-above])
(draw-box nil [{:span 16}, :box-below])

(draw-gap "Options (if IHL > 5)")
(draw-bottom)

</kroki>[[Test Flows|Return]]

BPMN Diagram sample

2026-05-19T14:09:35Z

Administrator: 1 wersja

<kroki lang="bpmn"><?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
typeLanguage="http://www.w3.org/2001/XMLSchema"
expressionLanguage="http://www.w3.org/1999/XPath"
targetNamespace="http://bpmn.io/schema/bpmn">
<message id="_1275940932310" />
<message id="_1275940932433" />
<process id="_6-1" isExecutable="false">
<startEvent id="StartEvent_1"/>
<laneSet id="ls_6-438">
<lane id="_6-650" name="clerk">
<flowNodeRef>OrderReceivedEvent</flowNodeRef>
<flowNodeRef>_6-652</flowNodeRef>
<flowNodeRef>_6-674</flowNodeRef>
<flowNodeRef>CalmCustomerTask</flowNodeRef>
</lane>
<lane id="_6-446" name="pizza chef">
<flowNodeRef>_6-463</flowNodeRef>
</lane>
<lane id="_6-448" name="delivery boy">
<flowNodeRef>_6-514</flowNodeRef>
<flowNodeRef>_6-565</flowNodeRef>
<flowNodeRef>_6-616</flowNodeRef>
</lane>
</laneSet>
</process>
<bpmndi:BPMNDiagram id="BPMNDiagram_1">
<bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="_6-1">
<bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1">
<omgdc:Bounds x="152" y="102" width="36" height="36"/>
</bpmndi:BPMNShape>
</bpmndi:BPMNPlane>
</bpmndi:BPMNDiagram>
</definitions></kroki>

Vim: settings

2026-05-19T14:09:34Z

Administrator: 1 wersja

Bellow is my experimental vim settings inspired by samples found on internet and actually included in my .vimrc:

<syntaxhighlight lang="bash">
colorscheme industry
syntax on
filetype on
filetype plugin on
filetype indent on
set nocompatible
set number
set cursorline
set cursorcolumn
set ignorecase
set nobackup
set tabstop=4
set shiftwidth=4
set expandtab
set scrolloff=10
set laststatus=2

set statusline=%<%f%m\ \[%{&ff}:%{&fenc}:%Y]\ %{getcwd()}\ \ \[%{strftime('%Y-%b-%d\ %a\ %I:%M\ %p')}\]\ %=\ Line:%l\/%L\ Column:%c%V\ %P
</syntaxhighlight>

[[Category:Bash]]