hibernate的命名策略，可以减少对数据库标识符命名的维护，进一步减少这部份命名的重复性代码量，以提高维护。
hibernate的命名方式，有两类，一类是显式命名，一类是隐式命名。
1）显式命名：在映射配置时，设置的数据库表名，列名等，就是进行显式命名。
2）隐式命名：显式命名一般不是必要的，所以可以选择当不设置名称，这时就交由hibernate进行隐式命名，另外隐式命名还包括那些不能进行显式命名的数据库标识符。接口implicitnamingstrategy，就是用于实现隐式命名。
3）过滤命名：接口physicalnamingstrategy，用于对显式命名或隐式命名进一步过滤处理。
示例：
testtable1impl.java
我要评论
@entity
// 隐式命名表名
@table
public class testtable1impl {
//---------------------------------------------------------------
// field
//---------------------------------------------------------------
@id
@column()
@generatedvalue(strategy = generationtype.identity)
private long testid;
@column(length = 20)
private string testname;
@manytoone
private testtable2impl testforeign;
//---------------------------------------------------------------
// method
//---------------------------------------------------------------
public long getid() {
return testid;
}
public void setid(long id) {
this.testid = id;
}
public string getname(){
return testname;
}
public void setname(string name){
this.testname = name;
}
public testtable2impl gettestforeign() {
return testforeign;
}
public void settestforeign(testtable2impl testforeign) {
this.testforeign = testforeign;
}
}
testtable2impl.java
@entity
// 显式命名表名
@table(name = "testtable2impl")
public class testtable2impl {
//---------------------------------------------------------------
// field
//---------------------------------------------------------------
@id
@column()
@generatedvalue(strategy = generationtype.identity)
private long testid;
@column(length = 20)
private string testname;
//---------------------------------------------------------------
// method
//---------------------------------------------------------------
public long getid() {
return testid;
}
public void setid(long id) {
this.testid = id;
}
public string getname(){
return testname;
}
public void setname(string name){
this.testname = name;
}
}
myimplicitnamingstrategyimpl.java
public class myimplicitnamingstrategyimpl extends implicitnamingstrategyjpacompliantimpl implements implicitnamingstrategy {
@override
public identifier determineprimarytablename(implicitentitynamesource source) {
identifier name = super.determineprimarytablename(source);
identifier result = tostandard(name, "impl");
system.out.println("implicitnamingstrategy / primarytablename -> \n\t" + name + " => " + result);
return result;
}
private identifier tostandard(identifier name, string... removesuffixes){
if(removesuffixes == null)
return name;
if(name == null)
return null;
string text = name.gettext();
if(removesuffixes != null){
for(string suffix : removesuffixes){
if(text.endswith(suffix))
text = text.substring(0, text.length() - suffix.length());
}
}
return new identifier(text, name.isquoted());
}
@override
public identifier determinejointablename(implicitjointablenamesource source) {
identifier name = super.determinejointablename(source);
system.out.println("implicitnamingstrategy / jointablename -> \n\t" + name);
return name;
}
@override
public identifier determinecollectiontablename(implicitcollectiontablenamesource source) {
identifier name = super.determinecollectiontablename(source);
system.out.println("implicitnamingstrategy / collectiontablename -> \n\t" + name);
return name;
}
@override
public identifier determinediscriminatorcolumnname(implicitdiscriminatorcolumnnamesource source) {
identifier name = super.determinediscriminatorcolumnname(source);
system.out.println("implicitnamingstrategy / discriminatorcolumnname -> \n\t" + name);
return name;
}
@override
public identifier determinetenantidcolumnname(implicittenantidcolumnnamesource source) {
identifier name = super.determinetenantidcolumnname(source);
system.out.println("implicitnamingstrategy / tenantidcolumnname -> \n\t" + name);
return name;
}
@override
public identifier determineidentifiercolumnname(implicitidentifiercolumnnamesource source) {
identifier name = super.determineidentifiercolumnname(source);
system.out.println("implicitnamingstrategy / identifiercolumnname -> \n\t" + name);
return name;
}
@override
public identifier determinebasiccolumnname(implicitbasiccolumnnamesource source) {
identifier name = super.determinebasiccolumnname(source);
system.out.println("implicitnamingstrategy / basiccolumnname -> \n\t" + name);
return name;
}
@override
public identifier determinejoincolumnname(implicitjoincolumnnamesource source) {
identifier name = super.determinejoincolumnname(source);
final string result;
if ( source.getnature() == implicitjoincolumnnamesource.nature.element_collection || source.getattributepath() == null ) {
result = transformentityname( source.getentitynaming() );
} else {
result = transformattributepath( source.getattributepath() );
}
system.out.println("implicitnamingstrategy / joincolumnname -> \n\t" + name + " => " + result);
return toidentifier( result, source.getbuildingcontext() );
}
@override
public identifier determineprimarykeyjoincolumnname(implicitprimarykeyjoincolumnnamesource source) {
identifier name = super.determineprimarykeyjoincolumnname(source);
system.out.println("implicitnamingstrategy / primarykeyjoincolumnname -> \n\t" + name);
return name;
}
@override
public identifier determineanydiscriminatorcolumnname(implicitanydiscriminatorcolumnnamesource source) {
identifier name = super.determineanydiscriminatorcolumnname(source);
system.out.println("implicitnamingstrategy / anydiscriminatorcolumnname -> \n\t" + name);
return name;
}
@override
public identifier determineanykeycolumnname(implicitanykeycolumnnamesource source) {
identifier name = super.determineanykeycolumnname(source);
system.out.println("implicitnamingstrategy / anykeycolumnname -> \n\t" + name);
return name;
}
@override
public identifier determinemapkeycolumnname(implicitmapkeycolumnnamesource source) {
identifier name = super.determinemapkeycolumnname(source);
system.out.println("implicitnamingstrategy / mapkeycolumnname -> \n\t" + name);
return name;
}
@override
public identifier determinelistindexcolumnname(implicitindexcolumnnamesource source) {
identifier name = super.determinelistindexcolumnname(source);
system.out.println("implicitnamingstrategy / listindexcolumnname -> \n\t" + name);
return name;
}
@override
public identifier determineforeignkeyname(implicitforeignkeynamesource source) {
identifier name = super.determineforeignkeyname(source);
string result = null;
string tablename = source.gettablename().gettext();
if(tablename.startswith(tablenamingconfig.table_prefix))
tablename = tablename.substring(tablenamingconfig.table_prefix.length());
if(source.getcolumnnames().size() == 1){
result = tablenamingconfig.foreign_key_prefix + tablename + "_" + source.getcolumnnames().get(0).gettext();
} else {
string columnname = source.getreferencedtablename().gettext();
if(columnname.startswith(tablenamingconfig.table_prefix))
columnname = columnname.substring(tablenamingconfig.table_prefix.length());
result = tablenamingconfig.foreign_key_prefix + tablename + "_" + columnname;
}
system.out.println("implicitnamingstrategy / foreignkeyname -> \n\t" + name + " => " + result);
return new identifier(result, name.isquoted());
}
@override
public identifier determineuniquekeyname(implicituniquekeynamesource source) {
identifier name = super.determineuniquekeyname(source);
system.out.println("implicitnamingstrategy / uniquekeyname -> \n\t" + name);
return name;
}
@override
public identifier determineindexname(implicitindexnamesource source) {
identifier name = super.determineindexname(source);
system.out.println("implicitnamingstrategy / indexname -> \n\t" + name);
return name;
}
}
myphysicalnamingstrategyimpl.java
public class myphysicalnamingstrategyimpl implements physicalnamingstrategy {
@override
public identifier tophysicalcatalogname(identifier name, jdbcenvironment jdbcenvironment) {
system.out.println("physicalnamingstrategy / catalog -> \n\t" + name);
return name;
}
@override
public identifier tophysicalschemaname(identifier name, jdbcenvironment jdbcenvironment) {
system.out.println("physicalnamingstrategy / schema -> \n\t" + name);
return name;
}
@override
public identifier tophysicaltablename(identifier name, jdbcenvironment jdbcenvironment) {
identifier result = tostandard(name, "tb_");
system.out.println("physicalnamingstrategy / table -> \n\t" + name + " => " + result);
return result;
}
@override
public identifier tophysicalsequencename(identifier name, jdbcenvironment jdbcenvironment) {
system.out.println("physicalnamingstrategy / sequence -> \n\t" + name);
return name;
}
@override
public identifier tophysicalcolumnname(identifier name, jdbcenvironment jdbcenvironment) {
identifier result = tostandard(name);
system.out.println("physicalnamingstrategy / column -> \n\t" + name + " => " + result);
return result;
}
private identifier tostandard(identifier name){
return tostandard(name, null);
}
private identifier tostandard(identifier name, string prefix){
if(name == null)
return null;
string text = name.gettext();
stringbuffer buffer = new stringbuffer();
if(prefix != null)
buffer.append(prefix);
char[] chars = text.tochararray();
for(int i=0, len=chars.length; i<len; i++){
char c1 = chars[i];
if(c1 >= 'a' && c1 <= 'z'){
if(i > 0 && i + 1 < len){
if(chars[i + 1] < 'a' || chars[i + 1] > 'z')
buffer.append('_');
}
c1 = (char) (c1 - 'a' + 'a');
}
buffer.append(c1);
}
return new identifier(buffer.tostring(), name.isquoted());
}
}
tablenamingconfig.java
public class tablenamingconfig {
public static final string table_prefix = "tb_";
public static final string foreign_key_prefix = "fk_";
}
spring.xml
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemalocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
<!-- 配置数据源 -->
<bean id="datasource" class="com.mchange.v2.c3p0.combopooleddatasource">
<property name="driverclass" value="com.mysql.jdbc.driver"></property>
<property name="jdbcurl" value="jdbc:mysql://localhost:3306/test?usessl=false"></property>
<property name="user" value="root"></property>
<property name="password" value="123456"></property>
</bean>
<bean id="physicalnamingstrategy" class="test.myphysicalnamingstrategyimpl"></bean>
<bean id="implicitnamingstrategy" class="test.myimplicitnamingstrategyimpl"></bean>
<bean id="sessionfactory" class="org.springframework.orm.hibernate5.localsessionfactorybean">
<property name="datasource" ref="datasource" />
<property name="packagestoscan">
<list>
<!-- 可以加多个包 -->
<value>test</value>
</list>
</property>
<property name="hibernateproperties">
<props>
<prop key="hibernate.hbm2ddl.auto">create-drop</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.mysql5dialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
</props>
</property>
<property name="physicalnamingstrategy" ref="physicalnamingstrategy"></property>
<property name="implicitnamingstrategy" ref="implicitnamingstrategy"></property>
</bean>
</beans>
test.java
public class test {
public static void main(string[] params){
// 命名策略
new test().test();
/*
physicalnamingstrategy / catalog ->
null
physicalnamingstrategy / catalog ->
null
physicalnamingstrategy / column ->
dtype => dtype
implicitnamingstrategy / primarytablename ->
testtable1impl => testtable1
physicalnamingstrategy / table ->
testtable1 => tb_test_table1
implicitnamingstrategy / basiccolumnname ->
testid
physicalnamingstrategy / column ->
testid => test_id
implicitnamingstrategy / basiccolumnname ->
testid
implicitnamingstrategy / basiccolumnname ->
testforeign
physicalnamingstrategy / column ->
testforeign => test_foreign
implicitnamingstrategy / basiccolumnname ->
testname
physicalnamingstrategy / column ->
testname => test_name
implicitnamingstrategy / basiccolumnname ->
testname
physicalnamingstrategy / column ->
dtype => dtype
physicalnamingstrategy / table ->
testtable2impl => tb_test_table2_impl
implicitnamingstrategy / basiccolumnname ->
testid
physicalnamingstrategy / column ->
testid => test_id
implicitnamingstrategy / basiccolumnname ->
testid
implicitnamingstrategy / basiccolumnname ->
testname
physicalnamingstrategy / column ->
testname => test_name
implicitnamingstrategy / basiccolumnname ->
testname
implicitnamingstrategy / joincolumnname ->
testforeign_testid => testforeign
physicalnamingstrategy / column ->
testforeign => test_foreign
implicitnamingstrategy / foreignkeyname ->
fklnurug7wfle1u6fc5oulnrx94 => fk_test_table1_test_foreign
hibernate:
alter table tb_test_table1
drop
foreign key fk_test_table1_test_foreign
hibernate:
drop table if exists tb_test_table1
hibernate:
drop table if exists tb_test_table2_impl
hibernate:
create table tb_test_table1 (
test_id bigint not null auto_increment,
test_name varchar(20),
test_foreign bigint,
primary key (test_id)
)
hibernate:
create table tb_test_table2_impl (
test_id bigint not null auto_increment,
test_name varchar(20),
primary key (test_id)
)
hibernate:
alter table tb_test_table1
add constraint fk_test_table1_test_foreign
foreign key (test_foreign)
references tb_test_table2_impl (test_id)
hibernate:
alter table tb_test_table1
drop
foreign key fk_test_table1_test_foreign
hibernate:
drop table if exists tb_test_table1
hibernate:
drop table if exists tb_test_table2_impl
*/
}
public void test(){
applicationcontext context = new classpathxmlapplicationcontext("spring.xml", this.getclass());
sessionfactory factory = null;
try {
factory = (sessionfactory) context.getbean("sessionfactory");
} finally {
if(factory != null){
factory.close();
factory = null;
}
}
}
}
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持移动技术网！
如对本文有疑问， 点击进行留言回复！！
输入正整数n，输出大于正整数n的最小的质数——以Java语言为例
ExceptionUtil: 转换Exception 的printStackTrace 输出为字符串
网友评论