simple-jpa 0.8

In order to setup your persistence layer, you need to call create-simple-jpa script. This is usually performed once for every new project. create-simple-jpa will create database user and schema for you if they don’t exists. Current version of simple-jpa only supports MySQL Server and Apache Derby Embedded setup. If your database is not supported, you should configure your database manually.

If you use MySQL Server, you can execute create-simple-jpa like:

Because hibernate is default value for -provider and mysql is default value for -jdbc, you can ommit them:

create-simple-jpa will check if sample database is exists or not. If sample database doesn’t exists, it will be created. Because this operation requires root user and its password, you need to provide a value in -rootPassword. This password won’t be saved in your application. create-simple-jpa also creates new database user called steven with default password 12345 if it doesn’t exists yet. This user will have full privilleges on sample database.

If you want to use Derby Embedded, you can execute create-simple-jpa like:

When using -jdbc=derby-embedded, it is better to use absolute path for -database value. Derby embedded database will be created at the specified location. The draw back of using absolute path is you must make sure database is copied to the proper location when you distribute your application.

Root password is not required when using Derby embedded. If you didn’t specify root password, create-simple-jpa will create root user with password equals to user password (in this sample, it is 12345).

In addition to setup your database, create-simple-jpa also performs the following steps:

If you want create-simple-jpa to perform the operations above without touching your database, use -skipDatabase argument:

You can instruct your JPA provider to recreate database objects (tables) based on current domain classes by executing generate-schema script:

Rather than directly executing in target database, generate-schema can also store the generated SQL statements in a file:

The command above will create mydatabase.sql in current directory. This file contains SQL statements to create tables required by your application.

By default, JPA provider will read persistence layer configurations stored in persistence.xml. The following is a sample persistence.xml created by create-simple-jpa script:

You can add new or edit existing JPA configurations inside <properties/>. For example, setting javax.persistence.schema-generation.database.action to drop-and-create makes your JPA provider to recreate database tables everytime application is launched. You may want to disable this to make application startup faster. If you disable auto schema generation, you can still use generate-schema to create database tables manually.

In addition to persistence.xml, simple-jpa also reads JPA configurations stored in Config.groovy and external properties file. If more than one property are found, simple-jpa uses the value based on the following order:

The following lines show a sample configurations added to Config.groovy:

The advantage of storing configurations in Config.groovy is you can have different JPA configurations per Griffon environments. For example, the following configurations use different database for different environments:

If you run the application by using command like run-app, it will activate development environment. In this case, JPA uses database jdbc:mysql://localhost/exercises. If you activate test environment (for example by running test-app), JPA uses database jdbc:mysql://localhost/test. It also recreate tables in that database.

To avoid storing sensitive information such as JDBC URL, username dan password in your source code, you can take advantage of Griffon feature to include properties file from Config.groovy. For example, if you store JPA configuration to hibernate.properties, you can add the following line to Config.groovy to include your properties file:

You may want to configure your source code repository to make sure your properties file will never committed to public server.

simple-jpa can also be configured to read JPA properties from external properties file. You can define the location of this properties file by adding the following line to Config.groovy:

A sample db.properties will look like:

Configurations stored in this properties file will override existing configurations in Config.groovy and persistence.xml, but can be overriden by JVM system properties. If you didn’t change griffon.simplejpa.entityManager.propertiesFile, it defaults to simplejpa.properties. This means you can always override JPA configuration for existing distribution by adding a new file called simplejpa.properties in the same location when you launched the application.

simple-jpa supports obfuscating configuration value. For example, if you want to store obfuscated version of 12345, you need to execute the following command to retrieve its obsfuscated version:

Then, you can use the obfuscated version for any value in any location (such as Config.groovy, properties file or system propeties). For example, you can add the following line to Config.groovy:

simple-jpa provides persistence methods to deal with persistent domain class (marked by @Entity). To create such entity, you can use create-domain-class script, for example:

The command creates two new classes: domain.Invoice and domain.LineItem. It also add these classes to persistence.xml. You can change the default base packages for domain classes by setting griffon.simplejpa.domain.package in Config.groovy.

You can also specify subpackage when executing create-domain-class, for example:

The command creates three new classes: domain.sales.Invoice, domain.sales.LineItem and domain.inventory.Product.

Persistent domain classes in simple-jpa is a normal JPA entities. Just like when using JPA in Java, you can decorate JPA entity with JPA annotations such as @Entity, @OneToMany, @ManyToMany, @ManyToOne and others. See JPA documentation for more information about JPA annotations. The following show examples of persistent domain classes in simple-jpa:

@DomainClass is special annotation provided by simple-jpa. This annotation automatically adds the following property to the annotated class:

You aren’t required to add @DomainClass to every persistent domain classes, but some features such as Auditing will not work without the properties generated by @DomainClass. Of course, you can still code by hand the required properties in every entities.

To make it possible for Griffon’s artifacts to manage domain classes, simple-jpa injects persistence methods to them. By default, persistence methods are injected into controller, but you can change it by adding the following line to Config.groovy:

The configuration above will inject persistence methods to services and repositories. Repository is a custom artifact type provided by simple-jpa. You can create a new repository by using griffon create-repository, for example:

The script creates MyRepository.groovy in griffon-app/repositories.

To retrieve instance of repository, you can use code like:

For a simple application, it is usually acceptable to inject persistence methods to controllers. If you want a clear separation, you should inject persistence methods only to repositories. You must add @Transaction annotation to the injected artifacts to enable Transaction. Class generated by create-repository already has @Transaction, but Griffon’s controllers do not have @Transaction by default.

The following is list of persistence methods injected by simple-jpa:

To avoid conflict with existing methods in injected class, simple-jpa can add prefix to persistence methods. For example, you can add the following line to Config.groovy:

Now, every persistence methods that can be renamed will have jpa prefix. For example, you have to execute jpaPersist() rather than persist().

The easiest way to learn simple-jpa persistence methods is by using simple-jpa-console script:

It will launch a Groovy console where you can write code snippet and see the result.

The main advantage of Groovy console is you can edit existing code and execute it directly by selecting Script, Run (Ctrl+R). This is many times faster than relaunching application by using griffon run-app. You will find Groovy console very useful in testing your code snippet or understanding the result of persistence methods.

Basic generator is the default generator used by simple-jpa. It supports the following attribute types in domain class:

For example, the following domain class:

will be generated as:

To create a new record, user should enter required values in the editing area and click the 'Save’ button.

To update existing record, user must first select a row in table, enter the updated values in the editing area, and click the 'Save’ button.

To remove record from database, user must click the 'Delete’ button that will appear if table’s row is selected.

For domain class that have one-to-one association, basic generator generates a dialog to create, edit or remove the related entity. This feature requires cascading to be activated for the attribute.

For example, the following attribute declaration:

is represented by JButton that if clicked will open a dialog that allows user to modify the related Teacher. If this button is clicked in create operation, the dialog can be used to create a new instance of Teacher entity:

If this button is clicked in update operation, the dialog can be used to update or delete existing Teacher entity:

The naming convention for one-to-one MVC group and its artifact’s name is the target entity name with 'AsPair’ as suffix. For example, if target entity is Teacher, basic generator generates TeacherAsPairModel, TeacherAsPairView, and TeacherAsPairController. They are not to be confused with the standalone MVC group for Teacher such as TeacherModel, TeacherView, and TeacherController that may also exists in the project (for example they are used for displaying list of Teacher in their own screen and not as popup).

Basic generator also treats @Embedded attributes as equivalent of one-to-one attributes. For example, the following mapping generates the same view as the previous one:

For one-to-many associations, basic generator also generates a dialog. For example, the following attribute declaration:

is represented by JButton that if clicked will open a dialog that allows user to add or remove the list of Classroom entities that are associated with current entity. If this button is clicked in create operation, the dialog can be used to populate the collection with one or more Classroom:

If this button is clicked in update operation, the dialog can be used to add new entity to the collection, edit the value of entity in the collection, or remove an entity from the collection:

The naming convention for one-to-many attribute is the target entity name with 'AsChild’ as suffix. For example, if target entity is Classroom, basic generator generates ClassroomAsChildModel, ClassroomAsChildView, and ClassroomAsChildController. This is not to be confused with ClassroomModel, ClassroomView or ClassroomController that may also exists in the project.

Basic generator will also treat @ElementCollection attributes as equivalent of one-to-many attributes. For example, the following mapping creates the same view as the previous one:

For bidirectional associations, basic generator generates inverse attributes as labels because they are not editable. For example, the following domain classes:

will be generated as:

simple-jpa also shipped with a DDD generator that can selected by using -generator parameter such as in the following execution:

DDD generator rely on basic generator to perform most of its works. It generates views that are identical to those generated by basic generator. The only distinction is this generator will move JPA related methods and database transactions from controller into a separate repository.

For every @Entity annotated domain classes, DDD generator will create their corresponding repository classes. simple-jpa supports a custom Griffon’s artifact called repository. For example, if there is an entity called Student, DDD generator will create a new repository called StudentRepository in griffon-app/repositories. This artifact is a singleton. It is automatically injected into controller (and other Griffon’s artifacts) by defining a variable such as studentRepository.

To retrieve all repositories, use RepositoryManager.getRepositories() such as:

Repository artifact is lazy initialized. This means it won’t be created if it is not used. RepositoryManager.findRepository() can be used to retrieve an instance of repository. This method will create a new instance that will be reused later (singleton) when it is called for the first time.

DDD generator disables dynamic methods in controller and adds dynamic methods to repository by adding the following line to Config.groovy:

A generator usually has classes and multiple templates. Reusable logic for view generation is stored in classes. They will be invoked by templates. For example, the generator class is always available to template as g variable.

The easiest way to customize a generator is to modify its template. install-templates command can be used to install templates for simple-jpa built-in generator to current project:

The command will copy template files to src/templates/artifacts. The following is list of all template files used by simple-jpa built-in generators:

After these templates have been installed into current project, the next invocation of generate-all will be based on them.

For a more complex customization, a new generator may be created. The new generator can be extended from existing generator or simplejpa.scaffolding.generator.Generator. All generators have the following important methods:

For example, the following is a sample declaration of custom generator that does nothing:

The following command will use the custom generator:

You can use validate() method from injection enhanced artifact to validate an object. The first argument for this method is an object that will be validated. It is the only required argument. validate() returns true if requested object is successfully validated or false if it failed.

For example, the following code will print error message to console if invoice object is not valid:

The second parameter for validate() determine what validation group is in effect. The default value is Default group. To use a different group, you can pass the group class to validate(), for example:

The third parameter accepts an instance of view model (Griffon’s model). Use this to present error in presentation layer by highlighting related view’s component. See the next section for more information about error notification.

To help you in displaying information about failed validation, simple-jpa injects the following members to all view models (model in MVC group):

All builder’s nodes also has a special errorPath attribute that can be used to represent associated validation path (like property name of validated objects). If errors contains key equals to errorPath, the respective component will be highlighted.

For example, the following code will highlight the first JTextField:

When you start typing on the highlighted JTextField, its red background will disappear. This also remove existing entry in model.errors.

By default, simple-jpa use red background to notify failed validation. You can also create your own notification method by extending ErrorNotification. For example, the following implementation of ErrorNotification will highlight border on error:

To assign MyErrorNotification to a single component, you can use errorNotification attribute:

To use MyErrorNotification on all components, add the following line to Config.groovy:

The component responsible for removing error message is called ErrorCleaner. The following table lists all implementations of ErrorCleaner by default:

You can create your own implementation by creating a new class that implements ErrorCleaner. For example, the following implementation removes error notification after one second:

To register this ErrorCleaner for all JTextField, you can add the following line to Config.groovy:

If you want to apply the new ErrorCleaner to all components, use '*' instead of 'javax.swing.JTextField as key:

If validation is failed, simple-jpa stores validation message for the failed paths in model.errors. You can use values stored in model.errors to determine which paths have been failed and what are their corresponding messages. You can also change the default validation message by editing griffon-app\i18n\ValidationMessage.properties.

The following code shows how to retrieve validation messages:

If you want to display validation mesage as JLabel in view, you can use errorLabel() node. For example, you can change the previous view into:

errorLabel() is only visible if model.errors contains a key equals to its errorPath.

In some cases, validation may be failed because JTextField value in model is an empty String rather than null value. To ensure consistent behaviour, simple-jpa can be configured to translate all empty String into null value before performing validation. This feature is disabled by default. To enable it, add the following line to Config.groovy:

Use numberTextField() to bind text component with numeric property in view model. For example:

If you want to bind to a BigDecimal property in view model, you need to use decimalTextField(). For example:

Both numberTextField() and decimalTextField() generates a JFormattedTextField. The default formatter used by them is DecimalFormat.getNumberInstance(). You can use different formatter by using one of 'currency', 'percent', or 'integer' as value for type attribute. For example:

You can also change the property of current formatter by using attribute name that starts with nf and followed by formatter’s property name, for example:

If you want a MaskFormatter, you can use maskTextField():

In the sample above, mask 'AAA-####-##' allows user to input number of letter for the first three characters. The rests should be number.

You can use dateTimePicker() to allow user to input date or time (or both). This component should be binded to date data type from Joda Time library. If you don’t need time input or binding to property that uses Joda Time type, you can just use JXDatePicker from SwingX instead of this component.

dateVisible or timeVisible of this component determine which input is visible. By default, both values are true.

dateTimePicker() offers several bindable properties:

In most cases, you will need only one of those properties, but you can also bind to multiple properties to get the same value in different types:

dateTimePicker() internally uses JXDatePicker for date entry and JSpinner time entry. They are exposed as properties called datePicker and timeSpinner.

If you want to perform a code everytime date or time is changed, you can add a closure to selectedValueChanged property:

Table is one of the most important components in business application. That is why simple-jpa provides its own custom JTable called glazedTable(). It is designed to be binded to EventList from Glazed Lists library. If you don’t use Glazed Lists, you can just use the default table() instead of glazedTable().

glazedTable() should contains one or more glazedColumn() to represent every columns in table. Every glazedColumn() will display property or execute method of the object contained in the binded EventList.

For example, lets assume you have created the following domain classes:

A very simple use case of glazedTable() will be:

As you can see, name attribute of glazedColumn() set column’s caption and property attribute determine the column’s value. The following table lists all attributes for glazedColumn():

glazedColumn() is an instance of TableColumn. This means you can also set all of TableColumn public properties such as modelIndex, width, cellEditor, and cellRenderer in glazedColumn().

To retrieve column’s value based on custom calculation rather than property name, you can set a closure for expression attribute. You can also use short name exp instead of expression. Inside this closure, it refer to the object for current row.

For example, you can add third column which values are retrieved from Invoice.total() method:

You can change the size of a column by using its width property. If you pass a number to width, it will set minWidth, preferredWidth and maxWidth of current TableColumn to the same value. This means user won’t be able to resize the column. You can set the value for each of minWidth, preferredWidth and maxWidth by passing a List to width.

In the table above, first column is fixed and can’t be resized. The second column can be resized to a minimum 50 pixel and there is no limit for its maximum size. The third column can’t be resized to a size more than 200 pixels.

glazedColumn() can accept instance of DefaultTableHeaderRenderer, TableCellRenderer or TableCellEditor as child nodes. The common use case is to pass a TableCellRenderer to glazedColumn() in order to format the presentation of this column. You can use templateRenderer() to create an instance of TableCellRenderer that supports simple-jpa template renderer expression. See Template Renderer for more information about template renderer expression.

For example, you can add uppercase format to the first column, date format to the second column and currency format to the third column as in the following view:

Because templateRenderer() generates an instance of JLabel, you can set public properties of resulting JLabel by using their name as attribute in templateRenderer(). For example, to right align the third column, you can use the following code:

templateRenderer also supports custom condition that set its property based on some conditions. For example, the following view will set font color for third column to red if its value is less than $1000:

In addition to glazedColumn(), glazedTable() also accepts menuItem() as child node. This will add new menu when user right click on the table. By default, popup menu for glazedTable() consists of only two menu items: copy cell and print. The following is a sample view that add new popup menus:

The following table lists attributes that can be used in glazedTable():

glazedTable() creates an instance of JTable so you can also set any public properties of JTable as attribute in glazedTable().

simple-jpa a new templateRenderer attribute to comboBox() and list() node to allow you customize renderer without creating a new renderer class for every components. templateRenderer() in glazedColumn() also uses the same thing.

templateRenderer attribute accepts a closure or string. If templateRenderer is a closure, it will be executed and the result is displayed. Inside the closure, it refers to original value. You can also call the following built-in functions from inside this closure:

For example, the following code show how objects are displayed in JComboBox and JList without using templateRenderer:

Here is what it looks like after adding templateRenderer in view:

You can also pass a string to templateRenderer. The string can be a property name or method call. If it is a method call, it should be starts with '#' character. You can also call built-in functions by adding ':' followed by a function name.

simple-jpa provides mvcPopupButton() as a helper node to create a JButton that will display a modal dialog if it is clicked. The following steps will be performed if mvcPopupButton() is clicked:

The following code show how to use mvcPopupButton():

mvcPopupButton() relies to DialogUtils to create modal dialog. The following is lists of all available methods in DialogUtils:

You can use @Transaction annotation to wrap a method in transaction. This annotation should only be used on artifacts that have been injected by Persistence Methods. Using @Transaction on artifacts that don’t have persistence methods will raise errors.

The following code show the basic usage of @Transaction:

You can also apply @Transaction to all methods in the class by simply add the annotation at class level.

@Transaction accepts a value that can be Policy.NORMAL or Policy.SKIP.

Policy.NORMAL (default value) supports nested transaction. If methodA() calls methodB() and both methods are annotated by @Transaction, they are executed in the same transaction. If one of methodA() and methodB() raises an Exception, none of their queries will be committed.

Nested transaction only work if methods are called from within the same thread. If methodB() is executed by using method such as app.execFuture() or app.eventAsync(), simple-jpa can’t guarantee it will be part of caller transaction. This is especially true if thread pool is involved.

Policy.SKIP is used to tell simple-jpa to not apply transaction AST transformation to the annotated method. This can be useful if you use @Transaction at class level and want to avoid wrapping few methods in transaction.

You can also create transaction without using @Transaction annotation. This can be done by calling transaction methods manually. Because transaction methods is part of persistence methods, they are only available in injected artifacts. The following is list of transaction methods:

For example, if controllers are injected with persistence methods, you can use the following code to create new transaction:

withTransaction() allows you to wrap a closure inside transaction. For example, you can replace the previous sample code into:

You can always call persistence methods directly inside the closure. This is very useful if you call withTransaction from another class, for example:

Classes annotated by @DomainClass will automatically have the following auditing properties:

To disable automatic creation of auditing properties for a domain class, use excludeAuditing property. For example:

The value for auditing properties are set by JPA entity listener simplejpa.AuditingEntityListener. create-simple-jpa command by default will create griffon-app/conf/metainf/orm.xml to register simplejpa.AuditingEntityListener as default entity listener. The default content of generated orm.xml is:

Built-in scaffolding’s generator will generate views that has auditing properties in them. By default, generated views display java.util.Date by its string representation such as Wed Aug 20 13:09:11 ICT 2014. To display java.util.Date by using a custom formatter, style for both date and time can be specified in Config.groovy:

The configuration above will generate the following code in controller:

The following is list of available styles (see http://docs.oracle.com/javase/tutorial/i18n/format/dateFormat.html for more information):

simple-jpa expects the value of current user is stored in SimpleJpaUtil.user. Value for this property must be an an implementation of AuditableUser. For example, developer can create a domain class that implement AuditableUser such as:

The following code can be used to set current (logged) user:

The code above will set createdBy and modifiedBy of new entity or updated entity to 'guest'.

simple-jpa can display a login dialog by using SwingX JXLoginPane at startup time. To enable this feature, a service that is derived from org.jdesktop.swingx.auth.LoginService is required. The following is typical steps to create such service:

When application is started, the following login dialog will be displayed:

If user cancels the dialog, simple-jpa will terminate the application. If user enters the correct credentials (which means LoginService.authenticate() returns true), simple-jpa will display startup group as usual.

simple-jpa injects the following query methods:

To use named queries, you must defined them first, for example:

Now you can call Invoice.LargeAmount by using code like:

Named queries are parsed when application is launched. Although they make application startup slower, they are quick to serve you when you need them because they’re prepared.

As an alternative to named query, you can always directly call JP QL by using executeQuery(), for example:

JPA can hurt performance if your query return a very large result. This is because JPA provider needs to translate every rows from native SQL query into object (entities). Creating a lot of objects in a short time may leads to memory shortage in heap. To avoid these problems, you can use executeNativeQuery() to execute SQL:

Dynamic finder works by following certain pattern in method name. For example, if you want to select all Invoice, you can call the following method:

Finder starts with findAll always return a List. If nothing is found, it returns an empty List.

You can add a criteria by using adding by to the finder followed by property name, for example:

If you want to return only a single instance, drop all from the finder name, for example:

The finder returns an instance of Invoice or null if nothing is found.

You can combine multiple criteria by using logical operator and and or, for example:

In the previous examples, you’ve searched based on equality (eq). simple-jpa dynamic finders also supports different operators such as:

For example, to search for all invoices created in this month, you can use the following code:

In this another example, you find products by name using like operator:

You can search for nested properties by using double underscore (__) as separator. For example, the following query finds all products based on supplier’s location:

In addition to using dynamic finder, you can also perform query by using Dsl finder. Such finder requires a closure as argument. The following code show how to use Dsl Finder:

The advantage of using Dsl closure is you can build the query conditions based on certain condition. You can also add any code inside the closure. For example, the following code add query condition only if certain variables are not null:

You can also use nested properties by using double underscores (__) as separator, for example:

Named entity graph is a new feature in JPA 2.1. It allows you to define a flexible fetch graph without modifying your current query. For example, you can define named entity graph such as:

If you want to use named entity graph in simple-jpa finders, you should always start the name with domain class name followed by a period (.) before the actual name. To use named entity graph, add fetch or load to dynamic finder, for example:

In addition to using fetch in dynamic finder, you can also use named entity graph by passing them query configuration using fetchGraph or loadGraph as key. See Query Configuration for more information.

Most of finder methods described so far can receive a configuration parameter in form of Map. You can use the following values as its keys:

You can also add some of the query configurations described above in Config.groovy. This way the configuration is globally applied to all finders that can accepts it. The following table lists all query configurations that can be added in Config.groovy:

In unit test, you’re usually testing domain classes. This test should never requires database connection. Unfortunately, sometimes domain class may depends on persistence methods in repository, for example:

You can’t test Registration.reserveNumber() directly because it calls RegistrationRepository.nextNumber() that requires access to database. For example, the following unit test will fail:

To solve this problem, you need to create a stub repository, for example:

simple-jpa provides DbUnitTestCase to help you in performing integration testing that actually hits database. DbUnitTestCase uses DbUnit to populate databases with certain records for every test case. The following sample show a basic usage of DbUnitTestCase:

When you execute the test by using griffon test-app, setUpDatabase() is called before executing test methods. By default, setUpDatabase() performs a clean insert (DatabaseOperation.CLEAN_INSERT) on database. Tables contents are deleted first then new records are inserted based on the value in /project/data.xlsx. Because this process is repeated for every test methods, you can assume that database is in the expected state when test methods begin.

DbUnitTestCase supports the following format as data source:

DbUnitTestCase also executes the following SQL files if it founds them in root package:

By default, DbUnitTestCase performs DatabaseOperation.CLEAN_INSERT for every methods. You can change this by setting insertOperation with a different value, for example:

For advanced use case, you can always override or execute public methods provided by DbUnitTestCase:

This command is usually the first command that will be invoked before working with Java Persistence API (JPA). It will create persistence.xml and orm.xml in current project. It will also create some resource files that are commonly required when working with JPA.

The syntax for this command is:

or

For example, the following command will generate persistence.xml with a connection to MySQL database (user: steven, password: 12345, database schema: sample), uses Hibernate JPA, and creates user steven and sample schema if they are not exists:

The following command will do the same as the previous one:

The following command will generate persistence.xml with a connection to MySQL database (user: scott, password: tiger, database schema: ha), uses Hibernate JPA, and will not check if required user and schema are available:

If you use -jdbc=derby-embedded, -database should be a full path to directory such as C:/Users/me/mydb.

This command will create a new empty domain class and register it in persistence context file. Before creating domain class, the project must has persistence.xml file in metainf directory. To generate required files for working with JPA, use create-simple-jpa command.

Domain class will be generated in the package specified by griffon.simplejpa.model.package value. The default package is domain.

To change the default template used for generating domain clasess, execute install-templates command and edit SimplaJpaDomainClass.groovy.

The syntax for this command is:

or

or

Examples:

This command will create a new MVCGroup based on a domain class. The generated MVCGroup (consists of a view, a model and a controller) has the ability to perform CRUD operations on a domain class. This command can also generate a startup MVCGroup that act as container for the others.

Domain classes should be located in the package specified by griffon.simplejpa.model.package in Config.groovy. The default value for package is domain.

When the value of griffon.simplejpa.finders.alwaysExcludeSoftDeleted is true, the generated controller will call softDelete() instead of remove().

To change the default template used by this command, execute install-templates command and edit the generated template files.

The syntax for this command is:

or

or

For example, the following command will generate MVCGroup for all domain classes:

The following command will generate MVCGroup for all domain classes, overwriting existing files, and set the last MVCGroup as startup:

The following command will generate MVCGroup for domain class Student, Teacher, and Classroom:

The following command will generate MVCGroup for domain class Student and generate a container MVCGroup which name is MainGroup:

The following command will generate a container MVCGroup which name is MainGroup:

This command will add templates used by simple-jpa to current project in /src/templates/artifacts. This command is useful for changing templates that is used by simple-jpa generator. Developer can edit the templates and the next invocation of simple-jpa generator will based on them.

The syntax for this command is:

Example:

This command will launch Groovy Console loaded with Griffon and simple-jpa. Developer can use this command to test or execute code interactively.

For each loaded MVCGroup, there are three variables to refer to its model, view, and controller. For example, if MVCGroup name is student, developer can refer to its model, view, or controller by using the following variables: studentModel, studentController and studentView. Developer can also use app to refer to GriffonApplication. To display list of available variables, select Script, Inspect Variables.

When console is started, it only loads startup MVCGroup. To load the another MVCGroup, select simple-jpa, MVCGroups.

The syntax for this command is:

Examples:

This command will generate database schema based on current domain models mapping to database or scripts. Developer can use this command to retrieve SQL scripts that can be used to populate new database schema for current application.

The syntax for this command is:

or

or

Examples:

Use this command to generate obfuscated value that can be added to configuration file or simplejpa.properties. This is useful to hide sensitive information such as database password from novice users.

The syntax for this command is:

or

Examples:

The command above will generate obfuscated:AGHJLPazOUvt5ZjzRNnKaA==. This can be used as a substitution for configurations that accepts string value. For example, it can be used in Config.groovy:

Use this command to create a new repository. It is recommended to generate repository automatically by using DDD generator rather than create them manually using this command.

The syntax for this command is:

This command will create new repository class in griffon-app/repositories.

Examples: