为一对多或多对多关系添加域类关系，其中以该方法的后缀的属性名称表示关系的映射属性

`addTo*`方法是一种动态的方法，使用一个会自动添加实例的关联。它还自动配置双向关系，使双方都设置。

考虑上面例子中使用的这些domain类:

这个例子创造了一本新的小说类书籍和一本新的非小说类书籍，归属于一个作者。 addToFiction`是一个动态方法,因为 `Fiction 部分表示的`fiction`集合定义在domain类的`hasMany`属性中,同样的关系也表现在 `NonFiction`和`nonFiction`上. 通过调用 `Author`对象的`save()`方法,关联的 `Book`示例也保存入库, 尽管我们没有显示的调用它们的`save()`方法.

此外，调用addTo*方法会初始化关联的集合，并且会设置`Book`的`author`的引用关系。

还有一种更紧凑的方法，该方法接受一个“map”而不是一个域类实例，如下调用，则自动初始化`Book`对象:

以上代码可以运行，是因为GORM知道addTo被添加类型，可以使用标准的`Map`构造函数来创建实例.

将“detached”状态的domain类实例与当前Hibernate会话关联在一起

Hibernate在持久会话session中管理持久实例。每个请求创建新会话，并在请求结束时关闭。如果一个对象是从会话中获取并放置到一个Web范围如HttpSession，状态将变为“detached”，一旦Hibernate会话session关闭和废弃。你可以使用` attach() `方法重新附加现有的持久化实例对当前请求的Hibernate session。

Defines a "belongs to" relationship where the class specified by belongsTo assumes ownership of the relationship. This has the effect of controlling how saves and deletes cascade. The exact behaviour depends on the type of relationship:

In this example the Book class specifies that it belongs to the Author class, hence when an Author instance is deleted so are all its associated Book instances.

The belongsTo property abstracts the nature of the cascading behaviour in Hibernate. If you want one class to belong to another but not have a back reference, then you can specify a class or a list of classes as the value:

or:

Back references, i.e. properties linking back to the owner, can be added in one of two ways:

or:

In these examples, both techniques create an Author property named author. Also, the Map property can specify multiple properties and types if the class belongs to more than one owner.

The belongsTo property is simple and means you don’t have to worry about the Hibernate cascading strategies, but if you need more control over cascading you can use the ORM DSL. This allows fine grained control of cascading updates and deletes.

重装domain类的errors列表 . 如果domain类包含绑定或验证的错误时，将非常有用。这些错误可以通过程序纠正。如果不清除错误，验证将继续失败。

Allows the definition of declarative validation constraints. See validation in the user guide.

Constraints are defined using the declarative constraints DSL as described in the validation section of the user guide. Once evaluated, validation can be applied through the use of the validate method:

The static constrainedProperties property is a Map such that the keys in the Map are property names and the values associated with the keys are instances of {apiDocs}grails/validation/ConstrainedProperty.html[ConstrainedProperty]:

返回domain类对应的表的记录总数

使用domain类中的属性来查询相应记录的数目的动态方法

这是`Book`的domain类:

下面的用法都是可以的:

GORM 支持 Dynamic Finders 的概念. `countBy*`方法对符合给定的表达的记录进行计数

下面的操作名称可以被用在各自的动态方法中:

这些操作名称可以被看作关键字, 当您使用这些操作名称作为属性对domain类进行查询时可能会产生困惑. 更多信息请查看 dynamic finders 的用户向导.

创建并返回一个 Grails' HibernateCriteriaBuilder 的实例, 用作构建标准化查询.

用作构建criteria的方法 (like, and, or, between 等) 可以从HibernateCriteriaBuilder静态导入 (就像这篇文档下面的例子), 或者写为 "c.like(…​)", "c.between(…​)" 等.

要想使用分页, 你还需使用另一个查询来检索匹配结果的总数. 一个较好的方法是将分页值作为criteria方法的参数, 就像下面:

因为这个查询包括了分页参数 (max and offset), 它会返回一个含有`getTotalCount()`方法、可以得到分页数据总数的 PagedResultList. 两个查询依然执行，但执行得到的结果集和总数组合在`PagedResultList`中.

Criteria queries are a type-safe, advanced way to query that uses a Groovy builder to construct potentially complex queries. It is a much better alternative to using a StringBuilder to dynamically construct an HQL query. Refer to the user guide section on Criteria for usage instructions.

方法相关:

If you invoke the builder with no method name

the list() method will be invoked automatically. In other words, it’s the equivalent of

Below is a node reference for each criterion method:

With dynamic finders, you have access to options such as max, sort, etc. These are available to criteria queries as well, but they have different names:

Criteria also support the notion of projections. A projection is used to change the nature of the results. For example the following query uses a projection to count the number of distinct branch names that exist for each Account:

The following table summarizes the different projections and what they do:

Deletes a persistent instance.

The delete method informs the persistence context that a persistent instance should be deleted. Equivalent to the Hibernate delete method.

Parameters:

Discards any changes that have been made to a persistent instance.

The discard method informs the persistence context that the instance should not be saved. The discard method is equivalent to using Hibernate’s evict method.

Supports embedding domain components into domain classes - otherwise known as composition.

Given these domain classes:

Grails will generate a person database table that looks like:

An embedded component does not store its data in its own table as a regular domain class relationship does. Instead, the data is included in the owner’s table. So in the above example, the Country fields appear in the person table. This means that queries are faster because there is no join required, but you may end up with duplicate data across tables.

The embedded component class is typically declared in the same source file as the owning class or in its own file under src/main/groovy. You can put the component class under grails-app/domain, but if you do so Grails will automatically create a dedicated table for it. Putting the class under src/main/groovy is usually the best option because you can then share the component across multiple domain classes.

Querying on embedded properties is no different from querying on regular relationships, so you can for example still do:

where brazil and france are instances of Country.

An instance of the Spring {springapi}org/springframework/validation/Errors.html[Errors] interface containing data binding and/or validation errors.

The errors property is used by Grails during data binding to store type conversion errors and during validation when calling the validate or save methods.

You can also add your own errors using the {springapi}org/springframework/validation/Errors#reject(java/lang/String).html[reject] and {springapi}org/springframework/validation/Errors#rejectValue(java/lang/String,%20java/lang/String).html[rejectValue] methods:

In the example of reject above, 'user.password.doesnotmatch', is the error code corresponding to a value in grails-app/i18n/message.properties, \['password', 'class User'\] as Object\[\] is a Groovy cast from a List to an Object array to match the expected signature, and '\[Property \[{0}\] of class \[{1}\] does not match confirmation\]' is the default mapping string.

In the rejectValue example, 'password' is the field in the view to highlight using a <g:hasErrors> tag and 'user.password.doesnotmatch' is the i18n error code.

Executes HQL queries

The executeQuery method allows the execution of arbitrary HQL queries. HQL queries can return domain class instances, or `Array`s of specified data when the query selects individual fields or calculated values. The basic syntax is:

Parameters:

Updates the database with DML-style operations

GORM does not provide a deleteAll method as deleting data must be done with caution. To delete data you can use executeUpdate. The basic syntax is:

Parameters:

Checks whether an instance exists for the specified id

Parameters:

Allows the configuration of an associations fetch strategy (eager or lazy)

In this example the fetchMode static property specifies that the book association should be fetching eagerly

By default associations in Grails are fetched lazily (each record is read from the database only when it is first accessed from the collection). This makes sense for most cases, however in the case where you have a small number of records to fetch and/or are repeatedly required to load lazy associations (resulting in N+1 queries) it makes sense to use eager fetching.

In the case of eager fetching and a one-to-many association, the instance as well as the association will be initialized when they are loaded (eagerly). However, caution should be observed when using eager fetching, since being too eager can result in your entire database being loaded into memory!

Finds the first matching result for the given query or null if no instance is found

The find method allows querying with Hibernate’s query language HQL and querying by example. The basic syntax is:

Parameters:

Finds all of domain class instances matching the specified query

The findAll method allows querying with Hibernate’s query language HQL and querying by example, returning all matching instances. Pagination can be controlled using the max and offset parameters:

The findAll method supports the 2nd level cache:

The basic syntax for the method is:

Parameters:

Dynamic method that uses the properties of the domain class to create query method expressions that return all matching instances of the domain class

Given this domain class:

The following are all possible:

GORM supports the notion of Dynamic Finders. The findAllBy* method finds all the results for the given method expression.

Parameters:

Pagination and sorting parameters can be used as the last argument to a dynamic method:

If no items meet the supplied criteria an empty list is returned.

The following operator names can be used within the respective dynamic methods:

These operator names can be considered keywords, and you will run into problems when querying domain classes that have one of these names as property names. For more information on dynamic finders refer to the user guide.

Uses named arguments corresponding to property names of the domain class to execute a query returning all matching results.

Given the domain class:

You can query in the form:

Parameters:

Dynamic method that uses the properties of the domain class to execute a query returning the first matching result.

Given the domain class Book:

The following are all possible:

GORM supports the notion of Dynamic Finders. The findBy* method finds the first result for the given method expression.

The following operator names can be used within the respective dynamic methods:

The above operator names can be considered keywords, and you will run into problems when querying domain classes that have one of these names used as property names. For more information on dynamic finders refer to the user guide.

Dynamic method that uses the properties of the domain class to create query method expressions that return the first result of the query. This method behaves like findBy except that it will never return null. If a matching instance cannot be found then a new instance will be created and returned, populated with values represented in the query parameters. The difference between this method and findOrSaveBy is that this method will not save a newly created instance where findOrSaveBy does.

Given the domain class Book:

The following are all possible:

The following are roughly equivalent:

GORM supports the notion of Dynamic Finders. The findOrCreateBy* method finds the first result for the given method expression.

Uses named arguments that match the property names of the domain class to produce a query that returns the first result. This method behaves just like findWhere except that it will never return null. If a matching instance cannot be found then a new instance will be created, populated with values from the query parameters and returned. The difference between this method and findOrSaveWhere is that this method will not save a newly created instance where findOrSaveWhere does.

Given the domain class:

You can query in the form:

Parameters:

Dynamic method that uses the properties of the domain class to create query method expressions that return the first result of the query. This method behaves like findBy except that it will never return null. If a matching instance cannot be found then a new instance will be created, populated with values represented in the query parameters, saved and returned. The difference between this method and findOrCreateBy is that this method will save any newly created instance where findOrCreateBy does not.

Given the domain class Book:

The following are all possible:

The following are roughly equivalent:

GORM supports the notion of Dynamic Finders. The findOrSaveBy* method finds the first result for the given method expression.

Uses named arguments corresponding to property names of the domain class to execute a query returning the first matching result. This method behaves just like findWhere except that it will never return null. If a matching instance cannot be found in the database then a new instance is created, populated with values from the query parameters, saved and returned. The difference between this method and findOrCreateWhere is that this method will save a newly created instance where findOrCreateWhere does not.

Given the domain class:

You can query in the form:

Parameters:

Uses named arguments corresponding to domain class property names to execute a query returning the first matching result.

Given the domain class:

You can query in the form:

Parameters:

Retrieves the first instance of the domain class.

Given the domain class:

Parameters:

See also:

Retrieves an instance of the domain class for the specified id. null is returned if the row with the specified id doesn’t exist.

Parameters:

Retrieves a List of instances of the domain class for the specified ids, ordered by the original ids list. If some of the provided ids are null or there are no instances with these ids, the resulting List will have null values in those positions.

Parameters:

Retrieve the names of modified fields in a domain class instance.

This method is useful mostly for audit logging or other work done in a beforeUpdate event callback. Hibernate caches the original state of all loaded instances for dirty checking during a flush and this method exposes the names of modified fields so you can compare them with the current state.

Retrieve the original value of a field for a domain class instance.

This method is useful mostly for audit logging or other work done in a beforeUpdate event callback. Hibernate caches the original state of all loaded instances for dirty checking during a flush and this method exposes that data so you can compare it with the current state.

Check if a domain class instance has validation errors following a call to validate or save, or following data binding

Defines a one-to-many association between two classes.

In this example we define a one-to-many relationship between the Author and Book classes (one Author has many `Book`s)

By default GORM will create a property of type java.util.Set using the key inside the definition of the hasMany map. For example consider this definition:

Here a property of type java.util.Set called books will be created within the defining class. These can then be iterated over and manipulated:

Defines a bidirectional one-to-one association between two classes where the foreign key is in the child.

In this example we define a one-to-one relationship between the Face class and the Nose class

Use a hasOne association to store the foreign key reference in child table instead of the parent in a bidirectional one-to-one. The example presented above will generate the following table structure:

Notice that the foreign key face_id is stored in the nose table instead of the face table as with a normal one-to-one definition without belongsTo.

Returns the value of the identity property of the domain class regardless of the name of the identity property itself

Determines if a domain class instance is an instance of the specified class, resolving the actual class if the instance is a proxy.

Given the domain classes:

Then you can determine the type of the elements in a Container's children collection using

Parameters:

Returns whether the domain instance is attached to a currently active Hibernate session. This method is often used on conjunction with the merge or attach methods.

Persistent instances are associated with a persistence Session. A new Session is created for each request and is closed at the end of the request. If an object is read from the session and placed into a web scope such as the HttpSession it is seen as detached, since the persistence session has been closed. You can use the attach method to re-attach an existing persistent instance to the persistence session of the current request.

Checks to see if a domain class instance has been modified.

Parameters:

Retrieves the last instance of the domain class.

Given the domain class:

Parameters:

See also:

Lists instances of the domain class.

When max is specified as a named argument this will return a PagedResultList which has a getTotalCount() method to return the total number of matching records for pagination. Two queries are still run, but they’re run for you and the results and total count are combined in the PagedResultList.

Parameters:

Lists all of the instances of the domain class ordered by the property in the method expression

Parameters:

Returns a proxy instance of the domain class for the given identifier.

load usually returns a proxy for the instance which is initialized on-demand, when a method other than getId() is invoked. load() only returns null if the provided id is null, so you cannot use it to test for existence. If you provide an id for an instance that doesn’t exist, a proxy will be returned and an exception will be thrown only when you call any instance method other than getId().

If there is an existing instance with the same id in the Hibernate session or 2nd-level cache, load() will return that non-proxy instance instead of a proxy.

Parameters:

The lock method obtains a pessimistic lock using an SQL select ... for update.

The lock method obtains a pessimistic lock on an instance, locking the row in the database with select ... for update. The lock method is equivalent to using Hibernate’s LockMode.UPGRADE in combination with the http://docs.jboss.org/hibernate/orm/current/javadocs/org/hibernate/Session#lock(java/lang/Object, org/hibernate/LockMode).html[lock] method.

The lock is automatically released when the transaction commits. In Grails this is typically after an action has finished executing.

Refer to the section on Optimistic and Pessimistic locking in the user guide for info.

The mappedBy static property allows you to control whether an association is mapped as unidirectional or bidirectional, and which properties form the reverse direction in the case of bidirectional associations.

In this example the Airport class defines two bidirectional one-to-many associations. Without defining mappedBy this is impossible as GORM cannot differentiate which of the two properties on the other end of the association (either departureAirport or destinationAirport in the Route class) each one-to-many should be associated with.

The solution is to define mappedBy which tells the Airport class how each association relates to the other side.

Separate example for many-to-one relationships:

Grails needs to know whether associations are unidirectional or bidirectional, and in the case of the latter, which properties are involved from both sides. Normally it can infer this information, but when there are multiple properties with the same type its guess can sometimes be wrong. The mappedBy property is a simple map of property name pairs, where the key is the name of an association property in the current domain class and the value is the name of an association property in the domain class on the other side of the association (which may be itself). The examples above should clarify this.

You can also specify a value of "none" in the map, which indicates that the association is unidirectional. However, this won’t work if you actually have a domain property called "none" in the target class!

The mapping static property configures how GORM maps the domain class to the database. See the section on the ORM DSL in the user guide for more information.

This example uses the ORM DSL to map the Person class onto a table called people

The mapWith static property adds the ability to control if a domain class is being persisted.

In this example the Airport class will not be persisted to the database.

Merges a domain class instance back into the current persistence context and returns a new merged instance.

The merge method is similar in function to the save method, but not in behaviour. merge allows the merging of "detached" instances such as those stored in the HTTP session. Each persistent instance is associated with a persistence context. A new persistence context is created for each request. The result is that objects stored in the HTTP session lose their persistence context on subsequent requests. In this case you can’t simply call save as the domain class is not associated with a current context.

The merge method on the other hand lets you merge a detached object’s state back into the current Hibernate session. Unlike the save method this method returns a new instance of the class representing the re-attached object. In other words you must write code like this:

If you don’t use the return value of the merge method then you still have access to the original unmodified detached instance and you will get errors such as lazy initialization exceptions.

The merge method is defined in the Hibernate documentation as follows:

The merge method is equivalent to the Hibernate merge method.

Parameters:

The namedQueries static property defines named queries. Named queries support the criteria builder syntax. See the section on the Criteria Builder in the user guide for more information.

The list method on named queries supports the same attributes as the static list method added to domain classes (sort, order, ignoreCase, fetch etc…​). See the list docs for details.

Named criteria support listDistinct():

Named criteria support additional criteria being supplied at invocation time in the form of a criteria closure:

Named criteria may be chained together. When criteria are chained together, the query will be generated as if all of the chained criteria had been combined in a single criteria closure.

When a named query involves a domain class relationship and the relationship class defines a named query, that named query may be accessed directly as a method call. An example:

Allows access to the domain class properties as a Map and is typically used for data binding to perform type conversions allowing properties to be set from request parameters or other Maps.

Retrieves an instance of the domain class for the specified id in a read-only state. null is returned if the row with the specified id doesn’t exist.

The read method is similar to the get method except that automatic dirty detection is disabled. The instance isn’t truly read-only - you can modify it - but if it isn’t explicitly saved but has been modified, it won’t be updated in the database during a flush. But you can explicitly call save() and it will be updated. There is one exception to this though - any associated collections, for example an Author's books collection, will participate in automatic flushing and dirty detection. This is because mapped collections are treated differently than regular properties and they manage their own dirty checking indepenent of the containing domain class.

Parameters:

Refreshes a domain classes state from the database

Equivalent to the Hibernate refresh method.

Re-reads the state of the given instance from the underlying database. It is inadvisable to use this to implement long-running sessions that span many business tasks. However this method is useful in certain special circumstances. For example

Opposite of the addTo method in that it removes instances from an association.

Saves a new domain class instance or updates a modified persistent instance in the database, cascading updates to child instances if required.

The save method informs the persistence context that an instance should be saved or updated. The object will not be persisted immediately unless the flush argument is used:

The save method returns null if validation failed and the instance was not persisted, or the instance itself if successful. This lets you use "Groovy truth" (null is considered false) to write code like the following:

Parameters:

Defines a list of property names that should not be persisted to the database. This is often useful if you have read-only accessor methods ("getters") that are helper methods but get confused as being persistence-related.

Here we have an accessor that takes the name and converts it to uppercase. It doesn’t make sense to persist this derived value, so we mark it as transient adding its JavaBean property name to the transients list.

Validates a domain class against the applied constraints (see validation)

The validate method validates a domain class based on its defined Constraints. The errors are stored in the errors property of the domain class instance.

The validate method accepts an optional List argument which contains the names of the properties to be validated. When a List of names is specified, only those properties will be validated.

Parameters:

Defines a new grails.gorm.DetachedCriteria instance.

Basic query:

Conjunctions/Disjunctions:

Property comparison:

Querying Associations:

Subqueries:

The where method is a powerful new type-safe querying option introduced in Grails 2.0. For more information on using the where method see the dedicated section on Where Queries and Detached Criteria in the user guide.

Defines a new grails.gorm.DetachedCriteria instance that uses a disjunction (logical OR).

Basic query:

The where method defaults to a conjunction (logical AND) for the created query. The whereAny compliments the where method by allowing the creation of DetachedCriteria using a disjunction (logical OR).

The where method is a powerful new type-safe querying option introduced in Grails 2.0. For more information on using the where method see the dedicated section on Where Queries and Detached Criteria in the user guide.

Allows inline execution of Criteria queries. See the createCriteria method for reference.

If no matching records are found, an empty List is returned.

If a projection is specified:

Otherwise, it will return a List of matched instances of the class calling withCriteria.

The withCriteria method allows the inline definition of Criteria. Arguments to the [http://grails.github.io/grails-data-mapping/latest/api/grails/orm/HibernateCriteriaBuilder.html] can be passed as the first parameter:

Parameters:

Provides a way to execute code within the context of a new Hibernate session which shares the same transactional (JDBC Connection) resource as the currently bound session.

Parameters:

提供 Hibernate Session 对象的底层权限

参数:

允许编程式事务使用Spring的事务抽象。

命名参数可以根据需要作为参数传递，以控制事务的属性。

withTransaction 方法接受一个含有 TransactionStatus 参数的闭包。

TransactionStatus 对象可以被用来以编程方式控制事务回滚。

详情请参见 Programmatic Transactions 。

验证字符串值是否为空白字符串值''.

如果字符串值不能为空字符串值''，则设置为“false”.

错误代码 Code: className.propertyName.blank

注意：如果字符串为“null”，它将不能通过验证“blank: true”。在这种情况下，设置 nullable约束为`true`。

验证字符串值是有效的信用卡号

如果字符串必须是信用卡号码，则设置为“true”。内部使用`org.apache.commons.validator.CreditCardValidator`类。

错误代码 Code: className.propertyName.creditCard.invalid

验证字符串值是有效的电子邮件地址.

如果字符串值必须是电子邮件地址，则设置为“true”。内部使用`org.apache.commons.validator.EmailValidator`类。

错误代码 Code: className.propertyName.email.invalid

验证值是否在约束值的范围或集合中.

约束一个值，使其必须包含在给定的列表中.

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.not.inList

验证字符串值是否与给定的正则表达式匹配.

对字符串值应用正则表达式.

错误代码 Code: className.propertyName.matches.invalid

确保值不超过最大值.

可以设置最大值为任意实现接口implements `java.lang.Comparable`的类对象.值的类型必须和属性的类型相同。

注意: 如果值为`java.util.Date`类型，约束的值只在评估执行时创建一次。

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.max.exceeded

确保值的大小不超过最大值.

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.maxSize.exceeded

确保值不低于最小值

可以设置最小值为任意实现接口implements `java.lang.Comparable`的类对象.值的类型必须和属性的类型相同。

注意: 如果值为`java.util.Date`类型，约束的值只在评估执行时创建一次。

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.min.notmet

确保值的大小不低于最小值.

设置集合或数字属性的最小大小.

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.minSize.notmet

确保属性不等于指定值

错误代码 Code: className.propertyName.notEqual

允许属性设置为“null”,默认设置为`false`

如果属性允许设置为`null`值，设置为`true`.对应数据库会设置为allow null.

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.nullable

注意：web请求表单提交，对于没有输入值的输入框, 属性的值为空白字符串，不是`null`.

使用Groovy的Range类型以确保属性值在指定范围内

Groovy的Range类型可以包含数字类型`IntRange`或日期类型，或者任意类型（实现了implements Comparable ，并且提供`next` 和 previous 两个方法）

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.range.toosmall 或者 className.propertyName.range.toobig

设置为浮点数字所需的尺度（即小数点右边的位数）

设置为浮点数字所需的尺度（即小数点右边的位数）。这个限制适用于以下类型的属性： java.lang.Float, java.lang.Double, and java.math.BigDecimal （及其子类）。当验证被调用时，此约束确定该数字是否包含比刻度允许更多的非零小数位置。如果是这样，它将数字循环到由刻度允许的最大小数位数。此约束不会生成验证错误消息。

这种约束的影响参见 schema generation.

无错误代码 Code: N/A

使用Groovy的Range类型限制集合、数字或字符串长度的大小

设置集合的大小、数字属性或字符串长度.

注意: 目前这个约束不能用于 blank 或者 nullable.可以使用自定义验证这些组合.

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.size.toosmall 或 className.propertyName.size.toobig

在数据库级别将属性限制为唯一,会在数据库表上建立唯一性约束

如果属性必须是唯一的，则设置为`true`。这是一个持久的调用，将查询数据库。

警告：有可能会发生（虽然不可能在实践中出现）唯一性验证通过，但随后的保存失败。场景为：如果同时有其他的进程修改数据库在GORM检查的同时，那么相关调用将失败。为了防止这一点的唯一方法就是使用`SERIALIZABLE`隔离级别的事务，但对性能影响很大。 还可以通过定义将字段包含为参数值来定义多列的“唯一”约束。如果有另一个字段，请指定它的名称，但如果有多于一个字段，请使用列表List，例如:

示例:

这个例子中，每个`department`部门内`group`名是唯一的，不同的部门可以存在重名的组。组名本身不是唯一的.

示例2:

这个例子要求在一个部门和组内的 `username`用户名是唯一的。不同的部门或不同的组内可以存在重名的情况

这种约束的影响参见 schema generation.

错误代码 Code: className.propertyName.unique

验证字符串值是有效URL.

如果一个字符串是 URL设置为 true .

错误代码 Code: className.propertyName.url.invalid

为字段添加自定义约束.

自定义验证通过闭包来实现，并接受3个参数。 如果闭包接受0个或1个参数,参数值将被验证("it" 是闭包的第0个参数). 如果接受2个参数，第一个是值，第二个是domain类的实例. 如果接受3个参数，第一个是值，第二个是domain类的实例，第3个是Spring Errors 对象。

闭包可以返回:

请注意，在最后的错误信息，该属性的标签将使用在message.properties文件中的定义。否则，将使用类中定义的属性名称。

当显式传递的错误代码，通常不需要使用"return"关键词返回的错误代码，因为如果从闭包返回时，它将检查错误是否已连接到错误的对象。

这可以看作特例，闭包中传递了第3个参数，预计错误的对象`Errors`将直接更新。

在当前domain类的 HQL 查询中 Enable/disable auto import .

Usage: autoImport(boolean)

默认情况下，domain类在HQL查询是auto-imported，因此，您不需要指定整个类名（包括包），但是，如果在不同的包中有重复的domain类名，则名称不再是唯一的，会造成`org.hibernate.DuplicateMappingException`错误。禁用其中一个或两个domain类的自动导入来修复此错误，设置`autoImport` 为 false。记住，你需要在HQL的查询中使用完全的domain类名引用。

设置为false时，关闭自动时间戳功能

Usage: autoTimestamp(boolean)

缺省当domain类中的属性名为 dateCreated 和 lastUpdated , GORM会在数据库自定维护这两个字段。可以通过设置为false关闭此功能:

定制多少结果获取在懒加载执行时.

Usage: batchSize(integer)

针对`Author` 类拥有多个 Book`实例的延迟加载关联。GORM将执行一条查询`Author`和附加查询多条关联`Book`实例。 这就是著名的N+1问题，通常使用表连接处理，然而，关联表会消耗性能。 批量加载是针对延迟加载的一个优化方案，例如设置`batchSize`为10，并且当前作者拥有30本书. 系统将执行四次获取（一次`Author，3次批量10对象的获取），替换之前的31此获取:

也可以在关联端设置 batchSize :

配置domain类支持Hibernate二级缓存.

Usage: cache(boolean/string/map)

参数:

示例:

这将配置domain类使用’read-write' 缓存，需要提前确认配置的缓存政策被允许使用（缓存引擎提供支持）:

or

也可以在关联端设置缓存:

参照文档获取更多信息 Caching .

配置关联项的级联操作

Usage: association_name(cascade:string)

参数:

默认GORM会配置"belongs to"属性对象的级联操作为"all"，示例如下:

所以的持久化操作都会从`Author` 类传递到 Book 类。作者对象删除将导致关联的图书全部删除。

如果关联没有设置所有者("belongs to" 关联关系):

GORM默认使用"save-update"级联策略. 作者对象删除时，不会级联删除关联的图书。 使用`cascade`参数自定义级联行为:

以上配置，`Book`当成为孤儿(orphaned) 时会被删除。.

参看文档获取更多信息 transitive persistence .

自定义数据列的设置

Usage: property_name(map)

Arguments:

By default GORM uses the property name and type to determine how to map a property in the database. For example a String property is typically mapped as a varchar(255) column. You can customize these with column configuration arguments:

If you use a Hibernate type that requires multiple column definitions you can use the column method to define each column:

Note that if you have a static method that is the same name as one of your properties you are trying to configure or you use the same property name as one of the static GORM methods this can lead to conflicts. To avoid this scenario scope the mapping configuration using the delegate property:

设置生成表创建sql(DDL)时使用的注释.

Usage: comment(string)

参数:

Customizes the discriminator column used in table-per-hierarchy inheritance mapping. Has no effect when using table-per-subclass inheritance mapping.

Usage: discriminator(string/map)

Arguments:

By default when mapping inheritance Grails uses a single-table model where all classes share the same table. A discriminator column is used to determine the type for each row, by default the full class name. You can use the discriminator method to customize what’s stored:

You can also customize the discriminator column name:

Or you can use a formula:

Whether to dynamically build INSERT queries

Usage: dynamicInsert(boolean)

By default Hibernate generates all queries at startup and caches them. This helps performance since insert, update, and delete queries don’t have to be dynamically generated at runtime. However, there are certain circumstances where dynamic queries are useful.

For example if you were using custom UserType to hash passwords, every time an UPDATE occurred, the password would get re-hashed. The dynamicInsert method lets you turn off the dynamic creation of queries that uses only the properties that are needed to perform the insert.

Whether to dynamically build UPDATE queries

Usage: dynamicUpdate(boolean)

By default Hibernate generates all queries at startup and caches them. This helps performance since insert, update, and delete queries don’t have to be dynamically generated at runtime. However, there are certain circumstances where dynamic queries are useful.

For example if you were using custom UserType to hash passwords, every time an UPDATE occurred, the password would get re-hashed. The dynamicUpdate method lets you turn off the dynamic creation of queries that uses only the properties that are needed to perform the update.

Configures the fetching behavior of an association.

Usage: association_name(fetch:string)

Arguments:

By default GORM assumes fetching of associations is done using a SELECT when the association is accessed. If you prefer that the association be fetched eagerly at the same time then you can override the behavior:

Here the books association will be fetched using a join at the same time the author is retrieved, for example:

Note that excessive use of joins can be a performance bottleneck. See the section on Eager vs Lazing Fetching in the user guide.

Customizes the way the identifier for a domain class is generated

Usage: id(map)

Arguments:

By default GORM uses the native strategy to generate a database identifier for each entity (typically an auto-incrementing column or a sequence). You can alter this with the id methods generator argument:

You can also use the method to define a composite identifier:

or change the name of the property that defines the identifier:

You can also alter the column definition:

See the section on Custom Database Identity in the user guide for more information.

Specifies how foreign keys that reference missing rows are handled in many-to-one relationships.

Usage: association_name(ignoreNotFound: boolean)

When the data in the database is corrupt and a foreign key references a non existent record, Hibernate will complain with a "No row with the given identifier exists" message. For example, a LegacyCdDomain record may have a reference to a Thumbnail record with an ID of 1234, but the database may no longer contain a Thumbnail with that ID.

One possible way to load such corrupt data is to use the ignoreNotFound mapping option. If you set it to true, Hibernate will treat a missing row as a null association. So in the above example, our LegacyCdDomain instance would load but its thumbnail property would be null. Specifying a value of false for ignoreNotFound will result in Hibernate throwing an org.hibernate.ObjectNotFoundException.

The default value for this setting is false. It maps to Hibernate’s not-found property.

This settings can be useful if you have a legacy database with unusual behaviour when it comes to referential integrity.

Customizes the index column definition of an indexed collection such as a List or Map

Usage: association_name(indexColumn:map)

Arguments:

By default when mapping an indexed collection such as a Map or List the index is stored in a column called association_name_idx which is an integer type in the case of lists and a String in the case of maps. You can alter how the index column is mapped using the indexColumn argument:

Determines whether a property’s database column is set when a new instance is persisted.

Usage: association_name(insertable: boolean)

Useful in general where you don’t want to set an initial value (or include the column in the generated SQL) during an initial save().

In particular this is useful for one-to-many relationships. For example when you store the foreign key in the child table, it’s often efficient to save the child using only the foreign key of the parent. You do this by setting the parent object (and the parent foreign key) in the child entity. Setting the attributes insertable:false and updateable:false for the belongsTo parent object lets you insert and update using only the foreign key.

Customizes the join table used for undirectional one-to-many, many-to-many and primitive collection types.

Basic collection type:

Enum collection types:

Many-to-many:

Unidirectional One-to-many:

Usage: association_name(joinTable:map)

Arguments:

GORM has various strategies for mapping association types. Some of them, such as basic collection types and many-to-many associations, use a join table. You can customize how this join table is created using the joinTable argument.

Configures whether to use proxies and lazy loading for one-to-one and many-to-one associations.

Usage: association_name(lazy: boolean)

By default GORM single-ended associations are lazy in that when you load a domain instance, an associated domain is not loaded until accessed. Hibernate creates a dynamic proxy by subclassing the domain class and proxying all methods and property access.

This can have some strange side effects (see this page on proxies at the Hibernate site) particularly in relation to inheritance. You can tell Hibernate not use proxies for single-ended associations by using the lazy argument:

See the section on Eager vs Lazing Fetching in the user guide.

Customizes the default sort order of query results.

Usage: order(string)

Arguments:

By defaults results are sorted in ascending order. With the order method you can alter results to be sorted in descending order. See also the sort method.

Customizes the default property to sort by for query results.

Usage: sort(string/map)

By default results are sorted by creation date, and you can specify the column to order by in a query:

However, you can also configure the default sort property:

in which case the sort argument is no longer needed. You can also control the sort order:

自定义的domain类关联的数据库表的名称

Usage: table(string/map)

Arguments:

默认情况下，domain类的表的映射名字是基于类的名字。GORM将类名的java风格驼峰格式映射为表名时，使用下划线隔离。例如` productreview 成为 product_review `。你可以用`table`方法重写表名:

也可以指定 schema 和 catalog名称:

Configures the Hibernate type for a particular property.

Changing to a text type (CLOB or TEXT depending on database dialect):

User types with multiple columns:

Usage: association_name(type:string/class)

Hibernate will attempt to automatically select the appropriate database type from the field typed based on configuration in the Dialect class that is being used. But you can override the defaults if necessary. For example String values are mapped by default to varchar(255) columns. To store larger String values you can use a text type instead:

Hibernate also has the concept of custom UserType implementations. In this case you specify the UserType class. If the UserType maps to multiple columns you may need to specify a mapping for each column:

Determines whether a property’s database column is updated when persistent instances are updated.

Usage: association_name(updateable: boolean)

Useful in general where you don’t want to update a value (or include the column in the generated SQL) during a save().

In particular this is useful for one-to-many relationships. For example when you store the foreign key in the child table, it’s often efficient to save the child using only the foreign key of the parent. You do this by setting the parent object (and the parent foreign key) in the child entity. Setting the attributes insertable:false and updateable:false for the belongsTo parent object lets you insert and update using only the foreign key.

用于禁用乐观锁定或更改保持版本的列.

Usage: version(string/boolean)

默认情况下，GORM配置 optimistic locking 启用. 可以通过设置 version 方法的 `false`参数来禁用:

可以将名称传递到 `version`方法以更改数据库列的名称: