hibernate
Niestandardowa strategia nazewnictwa

Tworzenie i używanie niestandardowej strategii ImplicitNamingStrategy

Utworzenie niestandardowej ImplicitNamingStrategy pozwala dostosować sposób, w jaki Hibernacja przypisze nazwy do ImplicitNamingStrategy nazwanych atrybutów Entity , w tym kluczy obcych, unikalnych kluczy, kolumn identyfikacyjnych, podstawowych kolumn i innych.

Na przykład domyślnie Hibernacja będzie generować klucze obce, które są haszowane i wyglądają podobnie do:

FKe6hidh4u0qh8y1ijy59s2ee6m

Chociaż często nie jest to problem, możesz chcieć, aby nazwa była bardziej opisowa, na przykład:

FK_asset_tenant

Można to łatwo zrobić za pomocą niestandardowej ImplicitNamingStrategy .

Ten przykład rozszerza ImplicitNamingStrategyJpaCompliantImpl , jednak możesz zdecydować się na implementację ImplicitNamingStrategy jeśli chcesz.

import org.hibernate.boot.model.naming.Identifier;
import org.hibernate.boot.model.naming.ImplicitForeignKeyNameSource;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl;

public class CustomNamingStrategy extends ImplicitNamingStrategyJpaCompliantImpl {

    @Override
    public Identifier determineForeignKeyName(ImplicitForeignKeyNameSource source) {
        return toIdentifier("FK_" + source.getTableName().getCanonicalName() + "_" + source.getReferencedTableName().getCanonicalName(), source.getBuildingContext());
    }

}

Powiedzieć Hibernate który ImplicitNamingStrategy w użyciu, zdefiniować hibernate.implicit_naming_strategy nieruchomość w swojej persistence.xml lub hibernate.cfg.xml pliku jak poniżej:

<property name="hibernate.implicit_naming_strategy"
                  value="com.example.foo.bar.CustomNamingStrategy"/>

Lub możesz określić właściwość w pliku hibernate.properties , jak poniżej:

hibernate.implicit_naming_strategy=com.example.foo.bar.CustomNamingStrategy

W tym przykładzie wszystkie klucze obce, które nie mają wyraźnie zdefiniowanej name otrzymają teraz swoją nazwę od CustomNamingStrategy .

Niestandardowa strategia nazewnictwa fizycznego

Podczas mapowania naszych bytów na nazwy tabel baz danych polegamy na adnotacji @Table . Ale jeśli mamy konwencję nazewnictwa dla naszych nazw tabel bazy danych, możemy zaimplementować niestandardową fizyczną strategię nazewnictwa, aby hibernacja mogła obliczyć nazwy tabel na podstawie nazw jednostek, bez wyraźnego podawania tych nazw za @Table adnotacji @Table . To samo dotyczy mapowania atrybutów i kolumn.

Na przykład nasza nazwa podmiotu to:

ApplicationEventLog

A nasza nazwa tabeli to:

application_event_log

Nasza strategia nazewnictwa fizycznego musi zostać przekształcona z nazw jednostek, które są wielbłądami na nazwy tabel db, które są przypadkami węża. Możemy to osiągnąć poprzez rozszerzenie PhysicalNamingStrategyStandardImpl hibernacji:

import org.hibernate.boot.model.naming.Identifier;
import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl;
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;

public class PhysicalNamingStrategyImpl extends PhysicalNamingStrategyStandardImpl {

    private static final long serialVersionUID = 1L;
    public static final PhysicalNamingStrategyImpl INSTANCE = new PhysicalNamingStrategyImpl();

    @Override
    public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
        return new Identifier(addUnderscores(name.getText()), name.isQuoted());
    }

    @Override
    public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
        return new Identifier(addUnderscores(name.getText()), name.isQuoted());
    }

    protected static String addUnderscores(String name) {
        final StringBuilder buf = new StringBuilder(name);
        for (int i = 1; i < buf.length() - 1; i++) {
            if (Character.isLowerCase(buf.charAt(i - 1)) &&
                    Character.isUpperCase(buf.charAt(i)) &&
                    Character.isLowerCase(buf.charAt(i + 1))) {
                buf.insert(i++, '_');
            }
        }
        return buf.toString().toLowerCase(Locale.ROOT);
    }
}

toPhysicalTableName domyślne zachowanie metod toPhysicalTableName i toPhysicalColumnName celu zastosowania naszej konwencji nazewnictwa db.

Aby skorzystać z naszej niestandardowej implementacji, musimy zdefiniować właściwość hibernate.physical_naming_strategy i nadać jej nazwę naszej klasy PhysicalNamingStrategyImpl .

hibernate.physical_naming_strategy=com.example.foo.bar.PhysicalNamingStrategyImpl

W ten sposób możemy złagodzić nasz kod z adnotacji @Table i @Column , więc nasza klasa encji:

@Entity
public class ApplicationEventLog {
    private Date startTimestamp;
    private String logUser;
    private Integer eventSuccess;

    @Column(name="finish_dtl")
    private String finishDetails;
}

będzie poprawnie mapowany do tabeli db:

CREATE TABLE application_event_log (
  ...
  start_timestamp timestamp,
  log_user varchar(255),
  event_success int(11),
  finish_dtl varchar(2000),
  ...
)

Jak widać w powyższym przykładzie, nadal możemy jawnie podać nazwę obiektu db, jeśli z jakiegoś powodu nie jest on zgodny z naszą ogólną konwencją nazewnictwa: @Column(name="finish_dtl")