1. Scaffold Spring CRUD Application Wizard

Scaffolding can generate full or major portions of an application by applying standard application patterns from a minimal set of existing artifacts provided by the developer. This wizard is used for all CRUD application scaffolding functions.

Note: Spring scaffolding requires a MyEclipse Spring or Bling subscription.

Inputs

• Relational Database Tables
• POJOs
• JPA Entities
• Domain Objects

• Web Layer – if selected, one or more web clients
  • Spring MVC
  • Spring Web Flow
  • JavaServer Pages (JSP 2.0)
  • Adobe Flex
  • Google Web Toolkit (GWT)
  • iPhone
• Service Layer
• Domain Layer
• Data Access Layer

Scaffolding from Java Beans

Scaffold Spring CRUD Application >> Select Artifact Type(s) >> Select Artifacts >> Select Primary Keys >> Application Layers  and Packages >> Select Web Client >> Customize User Interface >> Persistence Connection >> Target Folders >> Summary

Scaffolding from JPA Entities and Spring DSL Domain Objects

Scaffold Spring CRUD Application >> Select Artifact Type(s) >> Select Artifacts >> Application Layers and Packages >> Select Web Client >> Customize User Interface >> Persistence Connection >> Target Folders >> Summary

Scaffolding from Database Tables

Scaffold Spring CRUD Application >> Select Artifact Type(s) >> Select DB Connection >> Select Tables >> DB Scaffolding Options >> Application Layers and Packages >> Select Web Client >> Customize User Interface >> Target Folders >> Summary

Notes:

• If you are using the Spring DSL, the scaffolding wizard also adds the corresponding  Spring DSL artifacts (model packages, controllers, services, etc…)  for all scaffolded application components to your project. They appear in the Spring DSL view of your project, and you can maintain and enhance the scaffolded  artifacts using the Spring DSL and Spring DSL Editors.
• Additional pages could be included in the wizard allowing you to set Spring-specific options and capabilities settings.

2.1 Select Artifact Type(s)

The Select Artifact Types page is used for specifying which type of artifacts (i.e., database tables, JPA entities, Java Beans) should be used as inputs to scaffolding. You can select from multiple artifact types.

Note: This page is shown only when the scaffolding wizard is invoked from the toolbar or the project. When scaffolding is invoked by right-clicking a Java artifact, this page is skipped.

Note: Using the database schema option must be done separately from the JPA Entity, Java Bean, and Spring DSL Domain Object options. If you want to scaffold from a database schema and other artifact types, you can run the wizard once using the database schema artifact type and then rerun the wizard with other artifact types.

2.2 Select Artifacts for Scaffolding

The Select Artifacts for Scaffolding page scans the project for specified artifact types and lets you select the specific artifacts to be used for scaffolding.

2.3 Select Primary Keys (for Java bean scaffolding only)

The Select Primary Key(s) page is for specifying the fields for any selected Java bean(s) that uniquely identify an instance of the Java bean.

Note: Since database tables, JPA entities, and Spring DSL domain objects already have declared primary keys, this page is applicable only for Java Bean scaffolding.

2.4 Application Layers and Packages

The Application Layers and Packages page is used for selecting which application layers are scaffolded and what package name should be used for generated Java/Spring code.

The selections on this page depend on what you’re trying to generate. By default all layers are enabled, and this results in the generation of a fully implemented application for the web clients you select on the next page (i.e., Spring MVC, Spring Web Flow, JavaServer Pages (JSP 2.0), Adobe Flex, Google Web Toolkit (GWT), and iPhone). However, in some cases you might want to only scaffold a few layers of the application. For example, you might already have implemented the JPA and DAO layer by hand or with other tooling, and you only want to scaffold the web layer and service layer. Perhaps you are planning to implement your back-end with Spring, but you want to implement the web layer with a different technology currently supported by scaffolding. In that case, you would probably only want to scaffold the service, domain, and data access layers.

Note: The selections on this page apply to all artifacts selected on previous wizard pages. If you want a different scaffolding configuration for different artifacts (or set of artifacts), then split the artifacts into groups that require similar scaffolding, and run this wizard once for each group.

Notes:

• By default the web, service, DAO, and domain package names are derived from the input artifact package name, and the package name can be overridden. If you are scaffolding multiple artifacts and you want code generated to packages relative to input artifact, then you can use the ${domainPackage} and ${domainPackageParent} tokens to refer the input artifact’s package or parent package, respectively.
• When scaffolding from a database schema, there isn’t a Java class from which to derive a package name. So the package names are empty, and you must provide the package name.
• The package selector is only for specifying the package name. Specify where you want the code generated on the Select Target Folders page

2.5 Select Web Clients

The Select Web Clients page is used for the specifying the desired web layer implementations for the current scaffolding.

2.6 Flex Options

The Flex Options page is used for specifying configuration information for Flex scaffolding. Currently the only option is to specify the home folder of the Flex SDK. By default this panel specifies the Flex SDK instance that is included with MyEclipse for Spring, but you can specify a different instance of the SDK by selecting it from the file system.

2.7 GWT Options

The GWT Options page is for specifying configuration information for GWT scaffolding, specifically which version of GWT application should be generated.

2.8 REST Options

The REST Options page is for specifying configuration information for REST web services.

2.9 Customize User Interface

The Customize User Interface page is for specifying which fields should be included in the generated list and picker UI components. Furthermore, you can customize the table headers. By default the field names are used as the table headers, but they can be changed by clicking the field and editing the field name.

Note: Currently the Picker UI components are generated only for GWT. If you aren’t scaffolding for GWT, the Picker column is disabled.

2.10 Specify Persistence Connection

The Specify Persistence Connection page is for configuring the runtime persistence connection of the scaffolded application by selecting a workspace database connection. The selected database connection properties are used to configure the persistence connection properties for the scaffolded application.

Note: This panel is not displayed when scaffolding from a database schema because the runtime persistence connection is automatically set to the DB connection used for selecting the tables to reverse engineer for scaffolding.

2.11 Runtime Dependencies

The Runtime Dependencies page is for adding dependent libraries to the current project. While you can independently add and remove libraries from the project, this page can bootstrap the project with a full set of libraries typically needed by a Spring application, including Spring libraries plus many other runtime libraries.

You can add project dependencies in three ways:

• Copy libraries to a project folder (lib), and add libraries to the build path. Benefit: more portable projects because projects aren’t reliant on MyEclipse plugins.
• Use Eclipse classpath containers, and add classpath containers to the build path. Benefit: smaller projects because libs are included.
• Update Maven POM files. Benefit: Maven manages dependencies.

2.12 Select Scaffolding Options

The Scaffolding options page is for specifying whether pre-existing artifacts should be updated. If these artifacts already exist in the project, you have the option of specifying whether they should be overwritten or skipped.

2.13 Select Target Folders

The Select Target Folders page is for specifying where source code, configuration files, and dependent libraries should be installed.

Note: This page is not shown when the project has the Spring DSL enabled. If the project has been enabled, then the required information in this page is derived from the code generation configuration.

2.14 Select DB Connection (for DB scaffolding only)

The Select DB Connection page is for specifying the database connection for accessing the database tables to be reverse-engineered for scaffolding.

2.15 Select Database Tables (for DB scaffolding only)

The Select Database Tables page is for selecting database tables to be reverse-engineered for scaffolding. Select the schema where the desired database tables are located. The dialects are defaulted based on data connection properties, but they can be overridden. Select the tables, including associated tables, to be used for scaffolding.

2.16 Database Scaffolding Options (for DB scaffolding only)

The Database Scaffolding Options page is for specifying parent objects and customizing object names. The table lists the objects to be generated. With scaffolding associations (e.g., one-to-many), the generated application enables associated objects to be managed as part of a parent object. Please check the objects that should be treated as parent objects. Deselected objects are treated as associated objects. The object name is automatically derived from the table name, but you can override the object name by double-clicking the name and specifying a new name.

2.17 Summary

The Summary panel provides a summary of all the actions to be performed by the wizard when the Finish button is clicked.

3. Add Spring Runtime Dependencies

The Add Spring Runtime Dependencies wizard is for adding dependent libraries to an Eclipse project. There are three steps to the wizard.

Add Spring Runtime Dependencies >> Intro >> Runtime Dependencies

Note: Additional pages could be included in the wizard allowing you to set Spring-specific options and capabilities settings.

3.1 Intro

The Intro page provides an overview of the wizard.

3.2 Runtime Dependencies

The Runtime Dependencies page is for adding dependent libraries to the current project. While you can independently add and remove libraries from the project, this page can bootstrap the project with a full set of libraries typically needed by a Spring application, including Spring libraries plus many other runtime libraries.

The libraries to add to the current project can be enabled or disabled by library group or library. The library groups can be expanded to see the specific libraries and versions.

4. Scaffold Spring Security

Security is an important part of a web application, and Spring Security provides a set of services that integrate with Spring-based applications. The Scaffold Spring Security wizard configures the application for Spring Security and secure services and URLs:

• Database – using a DB security realm configured to use a scaffolded set of database tables (users and authorities)
• LDAP – using LDAP security realm
• In-Memory – using an in-memory security realm

Note: Additional pages could be included in the wizard allowing you to set Spring-specific options and capabilities settings.

Database

Scaffold Spring Security >> Overview >> Security Options [Database] >> Select Package >> Select DB Connection >> Secure Services >> Secure URLs >> Configured Views >> Summary

LDAP

Scaffold Spring Security >> Overview >> Security Options [LDAP] >> LDAP Configuration >> Secure Services >> Secure URLs >> Configured Views >> Summary

In-Memory

Scaffold Spring Security >> Overview >> Security Options [In Memory] >> Secure Services >> Secure URLs >> Configured Views >> Summary

Note: When scaffolding using the In-Memory option, the spring security context file is automatically configured with two users:

• Name: admin : Password: admin : Role: ROLE_ADMIN
• Name: user : Password: user : Role: ROLE_USER

4.1 Overview

The Overview page provides an introduction to the Scaffold Spring Security wizard.

4.2 Security Options

The Security Options page prompts you for the security type and password encoding.

4.3 Secure Services

The Secure Services page scans your project for services (@Service and @Repository components) that can be secured. By default all services are secured (checked) and configured with IS_AUTHENTICATED_REMEMBERED access. The wizard lets you unsecure the service and edit the access.

4.4 Secure URLs

The Secure URLs page prompts you for URLs to be secured. Unlike the Secure Services page, the wizard secures only one URL (/secure/*) by default, and you must specify (add and remove) other URLs based on your security requirements.

4.5 Configured Views

The Configured Views page is for specifying the URLs for various login pages.

4.6 Select Target Folders

The Select Target Folders page prompts you for the folder into which code is generated.

4.7 Select Package (for DB security only)

When using the database security option, this wizard generates to JPA entities for you. The User JPA entity and UserDAO data access object is for storing user credentials. The Authorities JPA entity and AuthoritiesDAO data access object is for storing authorization data. The Select Package page prompts you for the Java package for generated code.

Note: The DB tables are automatically created for you, but you need to populate them with data.

4.8 Select DB Connection (for DB security only)

The Select DB Connection page prompts you for the database connection profile to be used for the persistence configuration of the User and Authorities DAOs.

4.9 LDAP Configuration (for LDAP security only)

The LDAP Configuration page prompts you for the LDAP information.

Scaffolding Spring Security- LDAP Configuration page

See LDAP Authentication information at http://static.springsource.org/spring-security/site/docs/3.1.x/reference/ldap.html

4.10 Summary

The Summary page provides a summary of all the actions to be performed by the wizard when the Finish button is clicked.

5. Import WSDL

MyEclipse can be used to implement a web service contract by importing the WSDL.

Import WSDL >> Select WSDL >> Summary

Note: Additional pages could be included in the wizard allowing you to set Spring-specific options and capabilities settings.

5.1 Select WSDL

The Select WSDL File page is for specifying the WSDL URL and specifying the package in which to store files.

5.2 Summary

The Summary page provides a summary of all the actions to be performed by the wizard when the Finish button is clicked.

6. Enable Spring DSL

The Enable Spring DSL wizard is used to configure a project to use the Spring DSL. By default this wizard is set up with conventional defaults that enable all options. When clicking Finish from the Setup panel, default configuration options are applied to the current project. To customize the configuration, there are seven optional steps to the wizard.

Enable Spring DSL >> Intro >> Web Layer Generation >> Service Layer Generation >> Domain Layer Generation >> Data Access Layer Generation >> Runtime Dependencies >> Summary

Notes:

• The Enable Spring DSL wizard provides a lot of flexibility, but the wizard is set by default with a typical Spring DSL configuration. You can just click the Finish button from the first panel, and the default configuration is applied to the selected project.
• Additional pages could be included in the wizard allowing you to set Spring-specific options and capabilities settings.

6.1 Intro

The Intro page provides information about what the wizard will do.

6.2 Web Layer Generation

The Web Layer Generation page is used for enabling and configuring code generation for the web layer of a Spring application, including controllers (@Controller), JUnit tests, and web layer Spring context files.

If enabled, this page lets you specify the project and folders to which you want to generate. While you will typically want to generate to the same project where the code generation metadata (Spring DSL) is stored, in some cases you might want to generate to a different project. For example, you might want to keep all metadata in one project and have all code and configuration files generated to another project. Alternatively, you might want to generate each layer to a separate project. In either case, you have full control over the target project and folders.

6.3 Service Layer Generation

The Service Layer Generation page is used for enabling and configuring code generation for the service layer of a Spring application, including services (@Service), service interfaces, JAX-WS web services, direct web remoting (DWR) services, JUnit tests, and service layer Spring context files.

If enabled, this page lets you specify the project and folders to which you want to generate. While you will typically want to generate to the same project where the code generation metadata (Spring DSL) is stored, in some cases you might want to generate to a different project. For example, you might want to keep metadata in one project and have all code and configuration files generated to another project. Alternatively, you might want to generate each layer to a separate project. In either case, you have full control over the target project and folders.

6.4 Domain Layer Generation

The Domain Layer Generation page is for enabling and configuring code generation for the domain layer of a Spring application, including POJOs, primary key classes, bean info classes, JPA Entities (@Entity), Spring Components (@Component), JUnit tests, and domain https://www.genuitec.com/products/myeclipse/learning-center/spring/overview-of-myeclipse-with-spring-support/ layer Spring context files.

If enabled, this page lets you specify the project and folders to which you want to generate. While you will typically want to generate to the same project where the code generation metadata (Spring DSL) is stored, in some cases you might want to generate to a different project. For example, you might want to keep metadata in one project and have all code and configuration files generated to another project. Alternatively, you might want to generate each layer to a separate project. In either, case you have full control over the target project and folders.

6.5 Data Access Layer Generation

The Data Access Layer Generation page is used for enabling and configuring code generation for the DAO layer of a Spring application, including Spring repositories (@Repository), JUnit tests, and DAO layer Spring context files.

If enabled, this page lets you specify the project and folders to which you want to generate. While you will typically want to generate to the same project where the code generation metadata (Spring DSL) is stored, in some cases you might want to generate to a different project. For example, you might want to keep metadata in one project and have all code and configuration files generated to another project. Alternatively, you might want to generate each layer to a separate project. In either case, you have full control over the target project and folders.

6.6 Configure Project Libraries

The Configure Project Libraries page is for adding dependent libraries to the current project. While you can independently add and remove libraries from the project, this page can bootstrap the project with a full set of libraries typically needed by a Spring application, including Spring libraries plus many other runtime libraries.

The libraries to add to the current project can be enabled or disabled by library group or library. The library groups can be expanded to see the specific libraries and versions.

Notes:

• Beware of duplicate dependencies. When running this wizard on pre-existing projects, many of the libraries could already exist in the current project. This wizard doesn’t take into account existing libraries, so special care must be taken when adding libraries. Dependent libraries don’t have to be added using this wizard. They can always be added later using the Add Spring Runtime Dependencies wizard.
• This page adds dependencies to only the current project. If you need to add dependencies to another project (i.e., in a multi-project scenario), then you can add dependencies to the other target projects using the Add Spring Runtime Dependencies wizard.

6.7 Summary

The Summary page provides a summary of the actions to be performed by the wizard when the Finish button is clicked.