下面列出了怎么用org.hibernate.usertype.UserType的API类实例代码及写法,或者点击链接到github查看源代码。
public Type byClass(Class clazz, Properties parameters) {
if ( Type.class.isAssignableFrom( clazz ) ) {
return type( clazz, parameters );
}
if ( CompositeUserType.class.isAssignableFrom( clazz ) ) {
return customComponent( clazz, parameters );
}
if ( UserType.class.isAssignableFrom( clazz ) ) {
return custom( clazz, parameters );
}
if ( Lifecycle.class.isAssignableFrom( clazz ) ) {
// not really a many-to-one association *necessarily*
return manyToOne( clazz.getName() );
}
if ( Serializable.class.isAssignableFrom( clazz ) ) {
return serializable( clazz );
}
return null;
}
public CustomType custom(Class<UserType> typeClass, Properties parameters) {
try {
UserType userType = typeClass.newInstance();
if ( TypeConfigurationAware.class.isInstance( userType ) ) {
( (TypeConfigurationAware) userType ).setTypeConfiguration( typeConfiguration );
}
injectParameters( userType, parameters );
return new CustomType( userType );
}
catch (Exception e) {
throw new MappingException( "Unable to instantiate custom type: " + typeClass.getName(), e );
}
}
/**
* @deprecated Only for use temporary use by {@link org.hibernate.Hibernate}
*/
@Deprecated
public static CustomType custom(Class<UserType> typeClass, Properties parameters, TypeScope scope) {
try {
UserType userType = typeClass.newInstance();
injectParameters( userType, parameters );
return new CustomType( userType );
}
catch (Exception e) {
throw new MappingException( "Unable to instantiate custom type: " + typeClass.getName(), e );
}
}
public CustomType(UserType userType, String[] registrationKeys) throws MappingException {
this.userType = userType;
this.name = userType.getClass().getName();
this.types = userType.sqlTypes();
this.dictatedSizes = Sized.class.isInstance( userType )
? ( (Sized) userType ).dictatedSizes()
: new Size[ types.length ];
this.defaultSizes = Sized.class.isInstance( userType )
? ( (Sized) userType ).defaultSizes()
: new Size[ types.length ];
this.customLogging = LoggableUserType.class.isInstance( userType );
this.registrationKeys = registrationKeys;
}
protected EntityManagerFactory newEntityManagerFactory() {
PersistenceUnitInfo persistenceUnitInfo = persistenceUnitInfo(getClass().getSimpleName());
Map<String, Object> configuration = new HashMap<>();
configuration.put(AvailableSettings.INTERCEPTOR, interceptor());
Integrator integrator = integrator();
if (integrator != null) {
configuration.put("hibernate.integrator_provider", (IntegratorProvider) () -> Collections.singletonList(integrator));
}
final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
configuration.put("hibernate.type_contributors", (TypeContributorList) () -> {
List<TypeContributor> typeContributors = new ArrayList<>();
for (Type additionalType : additionalTypes) {
if (additionalType instanceof BasicType) {
typeContributors.add((typeContributions, serviceRegistry) -> typeContributions.contributeType((BasicType) additionalType));
} else if (additionalType instanceof UserType) {
typeContributors.add((typeContributions, serviceRegistry) -> typeContributions.contributeType((UserType) additionalType));
} else if (additionalType instanceof CompositeUserType) {
typeContributors.add((typeContributions, serviceRegistry) -> typeContributions.contributeType((CompositeUserType) additionalType));
}
}
return typeContributors;
});
}
EntityManagerFactoryBuilderImpl entityManagerFactoryBuilder = new EntityManagerFactoryBuilderImpl(
new PersistenceUnitInfoDescriptor(persistenceUnitInfo), configuration
);
return entityManagerFactoryBuilder.build();
}
public CustomType(Class userTypeClass, Properties parameters) throws MappingException {
if ( !UserType.class.isAssignableFrom( userTypeClass ) ) {
throw new MappingException(
"Custom type does not implement UserType: " +
userTypeClass.getName()
);
}
name = userTypeClass.getName();
try {
userType = ( UserType ) userTypeClass.newInstance();
}
catch ( InstantiationException ie ) {
throw new MappingException(
"Cannot instantiate custom type: " +
userTypeClass.getName()
);
}
catch ( IllegalAccessException iae ) {
throw new MappingException(
"IllegalAccessException trying to instantiate custom type: " +
userTypeClass.getName()
);
}
TypeFactory.injectParameters( userType, parameters );
types = userType.sqlTypes();
customLogging = LoggableUserType.class.isAssignableFrom( userTypeClass );
}
public Configuration registerTypeOverride(UserType type, String[] keys) {
basicTypes.add( new CustomType( type, keys ) );
return this;
}
@Override
public MetadataBuilder applyBasicType(UserType type, String... keys) {
delegate.applyBasicType( type, keys );
return getThis();
}
public BasicTypeRegistration(UserType type, String[] keys) {
this( new CustomType( type, keys ), keys );
}
@Override
public MetadataBuilder applyBasicType(UserType type, String... keys) {
options.basicTypeRegistrations.add( new BasicTypeRegistration( type, keys ) );
return this;
}
@Override
public void contributeType(UserType type, String[] keys) {
options.basicTypeRegistrations.add( new BasicTypeRegistration( type, keys ) );
}
public void registerTypeOverride(UserType type, String[] keys) {
typeConfiguration.getBasicTypeRegistry().register( type, keys );
}
public CustomType(UserType userType) throws MappingException {
this( userType, ArrayHelper.EMPTY_STRING_ARRAY );
}
public UserType getUserType() {
return userType;
}
public void register(UserType type, String[] keys) {
register( new CustomType( type, keys ) );
}
private SessionFactory newSessionFactory() {
final BootstrapServiceRegistryBuilder bsrb = new BootstrapServiceRegistryBuilder()
.enableAutoClose();
Integrator integrator = integrator();
if (integrator != null) {
bsrb.applyIntegrator(integrator);
}
final BootstrapServiceRegistry bsr = bsrb.build();
final StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder(bsr)
.applySettings(properties())
.build();
final MetadataSources metadataSources = new MetadataSources(serviceRegistry);
for (Class annotatedClass : entities()) {
metadataSources.addAnnotatedClass(annotatedClass);
}
String[] packages = packages();
if (packages != null) {
for (String annotatedPackage : packages) {
metadataSources.addPackage(annotatedPackage);
}
}
String[] resources = resources();
if (resources != null) {
for (String resource : resources) {
metadataSources.addResource(resource);
}
}
final MetadataBuilder metadataBuilder = metadataSources.getMetadataBuilder();
metadataBuilder.enableNewIdentifierGeneratorSupport(true);
metadataBuilder.applyImplicitNamingStrategy(ImplicitNamingStrategyLegacyJpaImpl.INSTANCE);
final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
additionalTypes.stream().forEach(type -> {
metadataBuilder.applyTypes((typeContributions, serviceRegistry1) -> {
if(type instanceof BasicType) {
typeContributions.contributeType((BasicType) type);
} else if (type instanceof UserType ){
typeContributions.contributeType((UserType) type);
} else if (type instanceof CompositeUserType) {
typeContributions.contributeType((CompositeUserType) type);
}
});
});
}
MetadataImplementor metadata = (MetadataImplementor) metadataBuilder.build();
final SessionFactoryBuilder sfb = metadata.getSessionFactoryBuilder();
Interceptor interceptor = interceptor();
if (interceptor != null) {
sfb.applyInterceptor(interceptor);
}
return sfb.build();
}
private SessionFactory newLegacySessionFactory() {
Properties properties = properties();
Configuration configuration = new Configuration().addProperties(properties);
for (Class<?> entityClass : entities()) {
configuration.addAnnotatedClass(entityClass);
}
String[] packages = packages();
if (packages != null) {
for (String scannedPackage : packages) {
configuration.addPackage(scannedPackage);
}
}
String[] resources = resources();
if (resources != null) {
for (String resource : resources) {
configuration.addResource(resource);
}
}
Interceptor interceptor = interceptor();
if (interceptor != null) {
configuration.setInterceptor(interceptor);
}
final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
configuration.registerTypeContributor((typeContributions, serviceRegistry) -> {
additionalTypes.stream().forEach(type -> {
if (type instanceof BasicType) {
typeContributions.contributeType((BasicType) type);
} else if (type instanceof UserType) {
typeContributions.contributeType((UserType) type);
} else if (type instanceof CompositeUserType) {
typeContributions.contributeType((CompositeUserType) type);
}
});
});
}
return configuration.buildSessionFactory(
new StandardServiceRegistryBuilder()
.applySettings(properties)
.build()
);
}
private SessionFactory newSessionFactory() {
Properties properties = properties();
Configuration configuration = new Configuration().addProperties(properties);
for (Class<?> entityClass : entities()) {
configuration.addAnnotatedClass(entityClass);
}
String[] packages = packages();
if (packages != null) {
for (String scannedPackage : packages) {
configuration.addPackage(scannedPackage);
}
}
String[] resources = resources();
if (resources != null) {
for (String resource : resources) {
configuration.addResource(resource);
}
}
Interceptor interceptor = interceptor();
if (interceptor != null) {
configuration.setInterceptor(interceptor);
}
final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
configuration.registerTypeContributor(new TypeContributor() {
@Override
public void contribute(TypeContributions typeContributions, ServiceRegistry serviceRegistry) {
for (Type type : additionalTypes) {
if (type instanceof BasicType) {
typeContributions.contributeType((BasicType) type);
} else if (type instanceof UserType) {
typeContributions.contributeType((UserType) type, new String[]{type.getName()});
} else if (type instanceof CompositeUserType) {
typeContributions.contributeType((CompositeUserType) type, new String[]{type.getName()});
}
}
}
});
}
return configuration.buildSessionFactory(
new StandardServiceRegistryBuilder()
.applySettings(properties)
.build()
);
}
private SessionFactory newLegacySessionFactory() {
Properties properties = properties();
Configuration configuration = new Configuration().addProperties(properties);
for (Class<?> entityClass : entities()) {
configuration.addAnnotatedClass(entityClass);
}
String[] packages = packages();
if (packages != null) {
for (String scannedPackage : packages) {
configuration.addPackage(scannedPackage);
}
}
String[] resources = resources();
if (resources != null) {
for (String resource : resources) {
configuration.addResource(resource);
}
}
Interceptor interceptor = interceptor();
if (interceptor != null) {
configuration.setInterceptor(interceptor);
}
final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
configuration.registerTypeContributor(new TypeContributor() {
@Override
public void contribute(TypeContributions typeContributions, ServiceRegistry serviceRegistry) {
for (Type type : additionalTypes) {
if (type instanceof BasicType) {
typeContributions.contributeType((BasicType) type);
} else if (type instanceof UserType) {
typeContributions.contributeType((UserType) type);
} else if (type instanceof CompositeUserType) {
typeContributions.contributeType((CompositeUserType) type);
}
}
}
});
}
return configuration.buildSessionFactory(
new StandardServiceRegistryBuilder()
.applySettings(properties)
.build()
);
}
/**
* Uses heuristics to deduce a Hibernate type given a string naming the type or Java class.
* Return an instance of <tt>org.hibernate.type.Type</tt>.
*/
public static Type heuristicType(String typeName, Properties parameters)
throws MappingException {
Type type = TypeFactory.basic( typeName );
if ( type == null ) {
Class typeClass;
try {
typeClass = ReflectHelper.classForName( typeName );
}
catch (ClassNotFoundException cnfe) {
typeClass = null;
}
if ( typeClass != null ) {
if ( Type.class.isAssignableFrom( typeClass ) ) {
try {
type = (Type) typeClass.newInstance();
}
catch (Exception e) {
throw new MappingException(
"Could not instantiate Type: " + typeClass.getName(),
e
);
}
injectParameters(type, parameters);
}
else if ( CompositeUserType.class.isAssignableFrom( typeClass ) ) {
type = new CompositeCustomType( typeClass, parameters );
}
else if ( UserType.class.isAssignableFrom( typeClass ) ) {
type = new CustomType( typeClass, parameters );
}
else if ( Lifecycle.class.isAssignableFrom( typeClass ) ) {
type = Hibernate.entity( typeClass );
}
else if ( Serializable.class.isAssignableFrom( typeClass ) ) {
type = Hibernate.serializable( typeClass );
}
}
}
return type;
}
private SessionFactory newSessionFactory() {
final BootstrapServiceRegistryBuilder bsrb = new BootstrapServiceRegistryBuilder()
.enableAutoClose();
Integrator integrator = integrator();
if (integrator != null) {
bsrb.applyIntegrator( integrator );
}
final BootstrapServiceRegistry bsr = bsrb.build();
final StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder(bsr)
.applySettings(properties())
.build();
final MetadataSources metadataSources = new MetadataSources(serviceRegistry);
for (Class annotatedClass : entities()) {
metadataSources.addAnnotatedClass(annotatedClass);
}
String[] packages = packages();
if (packages != null) {
for (String annotatedPackage : packages) {
metadataSources.addPackage(annotatedPackage);
}
}
String[] resources = resources();
if (resources != null) {
for (String resource : resources) {
metadataSources.addResource(resource);
}
}
final MetadataBuilder metadataBuilder = metadataSources.getMetadataBuilder()
.enableNewIdentifierGeneratorSupport(true)
.applyImplicitNamingStrategy(ImplicitNamingStrategyLegacyJpaImpl.INSTANCE);
final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
additionalTypes.stream().forEach(type -> {
metadataBuilder.applyTypes((typeContributions, sr) -> {
if(type instanceof BasicType) {
typeContributions.contributeType((BasicType) type);
} else if (type instanceof UserType ){
typeContributions.contributeType((UserType) type);
} else if (type instanceof CompositeUserType) {
typeContributions.contributeType((CompositeUserType) type);
}
});
});
}
additionalMetadata(metadataBuilder);
MetadataImplementor metadata = (MetadataImplementor) metadataBuilder.build();
final SessionFactoryBuilder sfb = metadata.getSessionFactoryBuilder();
Interceptor interceptor = interceptor();
if(interceptor != null) {
sfb.applyInterceptor(interceptor);
}
return sfb.build();
}
private SessionFactory newLegacySessionFactory() {
Properties properties = properties();
Configuration configuration = new Configuration().addProperties(properties);
for(Class<?> entityClass : entities()) {
configuration.addAnnotatedClass(entityClass);
}
String[] packages = packages();
if(packages != null) {
for(String scannedPackage : packages) {
configuration.addPackage(scannedPackage);
}
}
String[] resources = resources();
if (resources != null) {
for (String resource : resources) {
configuration.addResource(resource);
}
}
Interceptor interceptor = interceptor();
if(interceptor != null) {
configuration.setInterceptor(interceptor);
}
final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
configuration.registerTypeContributor((typeContributions, serviceRegistry) -> {
additionalTypes.stream().forEach(type -> {
if(type instanceof BasicType) {
typeContributions.contributeType((BasicType) type);
} else if (type instanceof UserType ){
typeContributions.contributeType((UserType) type);
} else if (type instanceof CompositeUserType) {
typeContributions.contributeType((CompositeUserType) type);
}
});
});
}
return configuration.buildSessionFactory(
new StandardServiceRegistryBuilder()
.applySettings(properties)
.build()
);
}
private void registerType(Configuration configuration, UserType type) {
String className = type.returnedClass().getName();
configuration.registerTypeOverride(type, new String[] {className});
}
private void registerType(MetadataImplementor mi, UserType type) {
String className = type.returnedClass().getName();
mi.getTypeResolver().registerTypeOverride(type, new String[] {className});
}
/**
* {@inheritDoc}
*/
@Override
protected UserType[] getUserTypes() {
return userTypes;
}
/**
* {@inheritDoc}
*/
@Override
protected UserType[] getUserTypes() {
return userTypes;
}
/**
* {@inheritDoc}
*/
@Override
protected UserType[] getUserTypes() {
return userTypes;
}
/**
* {@inheritDoc}
*/
@Override
protected UserType[] getUserTypes() {
return userTypes;
}
/**
* {@inheritDoc}
*/
@Override
protected UserType[] getUserTypes() {
return userTypes;
}
public UserType getGeometryUserType() {
return new HsqlGeometryUserType();
}