MyEclipse for Spring - Reference

The Setup panel is for specifying which builders should be enabled, whether the Spring Nature should be applied to the project, and whether the Spring DSL should be visible.

The Web Layer Generation panel 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 panel lets you specify the project and folders to generate to. While you will typically want to generate to the same project where the code generation metadata (Spring DSL) is stored, in some cases you may want to generate to a different project. For example, you may want to keep all your metadata in one project and have all code and configuration files generated to another project. Alternatively you may want to generate each layer to a separate project. In either case you have full control over the target project and folders.

The Service Layer Generation panel 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 panel lets you specify the project and folders to generate to. While you will typically want to generate to the same project where the code generation metadata (Spring DSL) is stored, in some cases you may want to generate to a different project. For example, you may want to keep all your metadata in one project and have all code and configuration files generated to another project. Alternatively you may want to generate each layer to a separate project. In either case you have full control over the target project and folders.

The Domain Layer Generation panel is used 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 layer Spring context files.

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

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

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

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

This panel lets you add project dependencies in three ways:

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.

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

The Intro panel provides an overview of the wizard.

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

This panel lets you add project dependencies in three ways:

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.

The Copy Static Content panel is for boostrapping the web content folder with required web content files (i.e. javascript, jsp pages).

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

The Select Project panel is for selecting the project that contains the artifacts that will be used as inputs for Spring MVC scaffolding and/or selecting the destination project for scaffolded artifacts

The Select Artifact Types panel is used for specifying which type of artifacts should be used for scaffolding. You can select from multiple artifact types:

The Select Artifacts for Scaffolding panel is used for selecting the artifacts for scaffolding based on the selected artifact types.

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

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

The selections on this panel depend on what you're trying to generate. By default all layers are enabled, and this will result in the generation of a fully implemented Spring MVC application. However you may be interested in only scaffolding a few layers of the application. For example you may already have implemented the JPA and DAO layer by hand or with other tooling, and you would only want to scaffold the web and service layer. Perhaps you are planning to implement your back-end with Spring, but you want to implement the UI layer with Spring Web Flow, Google Web Toolkit (GWT), or Adobe Flex. In that case you would probably only want to scaffold the service, domain and DAO layers.

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

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

The Select DB Connection panel is for specifying the database connection for accessing the database tables that should be used for scaffolding.

The Select Database Tables panel is for selecting the database tables that should be used for scaffolding.

Select the schema where the desired database tables are located. The dialects will be defaulted based on the data connection properties, but they can be overridden.

Select all the tables, including associated tables, that should be used for scaffolding.

The Database Scaffolding Options panel is for step is for specifying the folder in the project that will contain all the Skyway modeling artifacts.

The following table lists the objects that are going to be generated. When scaffolding associations (one-to-one or one-to-many) the generated application will enable associated objects to be managed as part of a parent object. Please check the objects that should be treated as parent objects. Unchecked objects will be treated as associated objects.

The object name is automatically derived from the table name, but you can override the object name by double-clicking on the name and specifying a new name.

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

The Select Location panel prompts you for the package for User/Authorities JPA entities and DAO.

The Overview tab allows a user to describe the project and link to other tabs in the Project Editor. Refer to the following figure and table for details on this tab.

Use the Category Mapping tab to reconfigure the target projects for each artifact category. Each Spring DSL artifact is associated with an artifact category, and the artifact category can be individually configured to generate to a particular Eclipse project.

The Category Mapping tab is also used to disable automated updates to project dependencies. For a Maven-based project this option will prevent MyEclipse for Spring from automatically updating the Maven pom file (pom.xml). For an Eclipse-based project this option will prevent MyEclipse for Spring from automatically updating your classpath (build path). If disabled, you are responsible from manually maintaining the project classpath.

The Web Application tab is used to specify the default suffix that's used for operation URLs (for controllers) that are created using the New Operation Wizard.

The Enterprise Configuration tab of the Project Editor allows a user to configure the Spring Security settings for the project.

The Spring Configuration tab allows a user to configure the mail server.

The Code Generation tab is for configuring various project-level code generation options, including the collection type that should be use for persistent relationships, the templates project that should be used for code generation, and the default code generation options for the generated code.

Persistent Collection Type

Select the type of collection to use for persistent relationships.

Code Generation

This section configures the default code generation settings for the entire project. From the Project Editor there's an entry for every artifact that is generated using MyEclipse for Spring. The settings can be overridden individually on an artifact by using the artifact's code generation tab, which will only contain entries for the artifacts generated resources.

Here's a list of available code generation tokens that can be used for configuring code generation options.

The New Service window is for specifying the name of the service and the model package that will contain the service.

The Overview tab is used for providing a description of the Service, navigating to the files generated from the Service, and navigating to the other Service configuration tabs. Refer to the following figure and table for details on this tab.

The Variables tab is used for defining Service variables. Service variables are available to all service operations. Refer to the following figure and table for details on this tab.

The Spring Bean Configuration tab is used to configure the scope and @Transaction annotations for the Service. Refer to the following figure and table for details on this tab.

The Code Generation tab is for configuring the generation options for a Service. This tab shows you all the code artifacts that are generated and managed by the Spring DSL Service. Each entry in this table represents a code artifact that is generated for the Service. In addition to enabling and disabling code generation on an artifact-by-artifact basis, you can also customize the name of the artifact, the package used, and the location where the artifact is generated to.

Code Generation

The code generation settings can be specified at the project level, which will control the code generation settings for the entire project. The code generation settings can also be customized for each Service using the code generation tab from the respective Service.

For a description of the code generation settings available from the Service Editor, please refer the to Code Generation tab of the Project Editor.

The JAXWS Web Service tab is used for configuring the web service options for the Service. By default a Service isn't web service enabled. This tab is for enabling the Service to be published as a Web Service and for configuring the JAX-WS options for the Service and Operations. Refer to the following figure and tables for details on this tab.

When a Spring DSL Service is published as a web service, an endpoint interface is generated and annotated with the JAX-WS @WebService annotation. The following table describes the configuration options for the web service.

The handler chain and SOAP binding can be configured at the web service level. The @HandlerChain and @SOAPBinding annotations are generated into the endpoint interface.

Unless otherwise excluded, each operation in a Spring DSL Service is published as a web method. The operation in the endpoint interface is generated and annotated with the JAX-WS @WebMethod annotation. The following table describes the configuration options for the web method.

While the SOAP binding can be configured at the web service level, JAX-WS allows the SOAP binding to be customized at the web method level. The custom configurations in the following table will be reflected in the @SOAPBinding annotation generated for the web method. The request (@RequestWrapper) and response (@ResponseWrapper) of the web method can be also configured.

In JAX-WS the input parameters of a web method are configured using the @WebParam annotation. The following table lists the configuration options that will generated for the @WebParam annotation.

The DWR tab is used for configuring the DWR (direct web remoting) options for the Service. By default a Service isn't DWR enabled. This tab is for enabling the Service to be published as a Javascript library (that uses JSON for data transferring) using DWR. Refer to the following figure and table for details on this tab.

The following table describes the configuration options for the DWR service.

Unless otherwise excluded, each operation in a Spring DSL Service is published as a javascript function. The following table describes the DWR configuration options for the operations.

DWR will automatically generates some pages that can assist in developing with DWR. The DWR Service index page lists all the classes known to DWR. It's usefull for verifying which Spring DSL services are or are not DWR enabled. The URL for the accessing the index page is http://server:port//context/dwr/index.html

The New Web Controller window is for specifying the name of the web controller and the model package that will contain the web controller.

The Overview tab is used for providing a description of the Controller, navigating to the files generated from the Controller, and navigating to the other Controller configuration tabs. Refer to the following figure and table for details on this tab.

When Operations are added to a Controller, they are generated as Java methods in the controller. The Spring MVC framework provides a variety of annotations for specifying the behaviour of the Java methods and managing data binding, and the Sprint MVC tab assists in annotating the Java methods and configuring the annotations.

Here's a summary of the Spring MVC annotations:

An example might be helpful for understanding how the Spring MVC annotations are used with annotation-based controllers.

@Scope("singleton")
@Controller("CustomerController")
public class CustomerController {

  @RequestMapping(method = { RequestMethod.GET, RequestMethod.POST }, value = "/saveCustomer.html")
  public String saveCustomer(@ModelAttribute(value = "customer") Customer customer) {
     // 
  }

  @RequestMapping(method = { RequestMethod.GET, RequestMethod.POST }, value = "/selectCustomer.html")
  public ModelAndView selectCustomer(@RequestParam(required = true, value = "customernumberKey") 
                                     Integer customernumberKey) {
    //
  }

  @InitBinder
  public void initBinder(WebDataBinder binder, HttpServletRequest request) { // Register static property editors.
    binder.registerCustomEditor(java.util.Calendar.class, new org.execution.databinding.CustomCalendarEditor());
  }

  @ModelAttribute(value = "cities")
  public Set<Cities> getCities() {
   //
  }
}

The Spring MVC panel helps configure the Spring MVC annotations for the methods and method parameters in a controller. When clicking on the controller, the controller properties will be displayed for editting. When explanding the controller and clicking on an operation, the operation properties will be displayed for editting.

The Variables tab is used for defining Controller variables. Controller variables are available to all controller operations. Refer to the following figure and table for details on this tab.

The Spring Bean Configuration tab is used to configure the scope and @Transaction annotations for the Controller. Refer to the following figure and table for details on this tab.

The Code Generation tab is for configuring the generation options for a Controller. This tab shows you all the code artifacts that are generated and managed by the Spring DSL Controller. Each entry in this table represents a code artifact that is generated for the Controller. In addition to enabling and disabling code generation on an artifact-by-artifact basis, you can also customize the name of the artifact, the package used, and the location where the artifact is generated to.

Code Generation

The code generation settings can be specified at the project level, which will control the code generation settings for the entire project. The code generation settings can also be customized for each artifact using the code generation tab from the respective editor for the artifact.

For a description of the code generation settings available from the Service Editor, please refer the to Code Generation tab of the Project Editor.

The New Component window is for specifying the name of the component and the model package that will contain the component.

The Overview tab is used for providing a description of the Component, navigating to the files generated from the Component, and navigating to the other Component configuration tabs. Refer to the following figure and table for details on this tab.

The Variables tab is used for defining Component variables. Component variables are available to all component operations. Refer to the following figure and table for details on this tab.

The Code Generation tab is for configuring the generation options for a Component. This tab shows you all the code artifacts that are generated and managed by the Spring DSL Component. Each entry in this table represents a code artifact that is generated for the Component. In addition to enabling and disabling code generation on an artifact-by-artifact basis, you can also customize the name of the artifact, the package used, and the location where the artifact is generated to.

Code Generation

The code generation settings can be specified at the project level, which will control the code generation settings for the entire project. The code generation settings can also be customized for each artifact using the code generation tab from the respective editor for the artifact.

For a description of the code generation settings available from the Service Editor, please refer the to Code Generation tab of the Project Editor.

The Spring Bean Configuration tab is used to configure the scope and @Transaction annotations for the Component. Refer to the following figure and table for details on this tab.

The New Operation window is for specifying the name of the operation and the controller, component or service that will contain the operation.

If you are using model-driven development to implement your operations, then an action can automatically be created. If you aren't using MDD, then you should disable this option.

The Overview tab is used for providing a description of the Operation, navigating to the files generated from the Operation, navigating to the other configuration tabs, and defining operation exceptions. Refer to the following figure and table for details on this tab.

The Inputs/Outputs tab defines the input and output parameters of a particular operation. When this operation is invoked, the consumer (client) or the operation is required to map variables to the input and output parameters. Refer to the following figure and table for details on this tab.

The Spring Bean Configuration tab is used to configure the scope and @Transaction annotations for the Operation. Refer to the following figure and table for details on this tab.

The Code Generation tab is for configuring the generation options for an Operation. The implementation of an operation will be generated into the respective controller, component or service. However this tab shows any additional code artifacts that are generated and managed by the Spring DSL Operation. Each entry in this table represents a code artifact that is generated for the Operation. In addition to enabling and disabling code generation on an artifact-by-artifact basis, you can also customize the name of the artifact, the package used, and the location where the artifact is generated to.

Code Generation

The code generation settings can be specified at the project level, which will control the code generation settings for the entire project. The code generation settings can also be customized for each artifact using the code generation tab from the respective editor for the artifact.

For a description of the code generation settings available from the Service Editor, please refer the to Code Generation tab of the Project Editor.

The New Web Flow window is for specifying the name of the flow and the model package that will contain the flow.

The New Domain Object window is for specifying the name of the domain object and the model package that will contain the domain object.

The Overview tab is used for configuring the domain object fields, managing relationships and providing a description. Refer to the following figure and table for details on this tab.

This editor allows a user to describe the domain object, set relationships between other domain objects, and create and edit fields in the domian object. Refer to the following figure and table for details on this tab.

The domain object editor allows you to define relationships to a domain object.

Relationship Type

The Relationship Type defines the cardinality of the relationship from the perspective of the current Domain Object. The options are:

Bidirectional Relationships

When a relationship is added to another domain object, a unidirectional relationship is implied. Two independent unidirectional relationships can be linked together to create a bidirectional relationship. If you decide to define a bidirectional relationship, the cardinality and relationship names need to match.

Relationships Names

When defining a relationship between two data objects, the Domain Object editor will prompt you for a relationship name and a reverse name. These names will be used for accessing each other's related data. The relationship name is used to identify the relationship from the perspective of the current domain object. The reverse name is used to identify the relationship from the target data object type back to the current domain object.

Regarding relationship names, the Domain Object editor will default the domain object name as the relationship names, but you can very easily changed the name. It's a good idea to change these relationship names to something more semantically meaningful. While they have no impact on the functionality, these names will be the what you will see as your referencing these relationships in the services you create. These names should be meaningful, and it's recommended that you name them with the appropriate plurality for the relationship type.

The Persistence Mapping tab is used to control how the Domain Object will map into persistence in a database and how it will display throughout the rest of the project. This tab includes the Table and Field Mapping and Relationships sections. The Persistence Mapping tab will let you override the default table name and field names. Refer to the following figure and table for details on this tab.

When a domain object in configured to be persisted to a database, the database name and fields will be derived from the domain object. However there are occasions where a developer may want the table names and field names to be different than the object. When a domain object is created, MyEclipse for Spring will use the following peristence mapping defaults:

The Code Generation tab is for configuring the generation options for a Domain Object. This tab shows you all the code artifacts that are generated and managed by the Domain Oject. Each entry in this table represents a code artifact that is generated for the Domain Object. In addition to enabling and disabling code generation on an artifact-by-artifact basis, you can also customize the name of the artifact, the package used, and the location where the artifact is generated to.

Code Generation

The code generation settings can be specified at the project level, which will control the code generation settings for the entire project. The code generation settings can also be customized for each artifact using the code generation tab from the respective editor for the artifact.

For a description of the code generation settings available from the Service Editor, please refer the to Code Generation tab of the Project Editor.

The New Data Access window is for specifying the name of the data access object and the model package that will contain the data access object.

When you create a DAO, you can associate one or more domain objects with the DAO.

The Overview tab is used for associating domain objects to the DAO, providing a description of the DAO, and navigating to the files generated from the DAO. Refer to the following figure and table for details on this tab.

The Spring Bean Configuration tab is used to configure the scope and @Transaction annotations for the Data Access Object. Refer to the following figure and table for details on this tab.

The Database Configuration tab allows a user to select a database for this Data Access Object. Refer to the following figure and table for details on this tab.

The Code Generation tab is for configuring the generation options for a Data Access Object. This tab shows you all the code artifacts that are generated and managed by the Spring DSL DAO. Each entry in this table represents a code artifact that is generated for the DAO. In addition to enabling and disabling code generation on an artifact-by-artifact basis, you can also customize the name of the artifact, the package used, and the location where the artifact is generated to.

Code Generation

The code generation settings can be specified at the project level, which will control the code generation settings for the entire project. The code generation settings can also be customized for each artifact using the code generation tab from the respective editor for the artifact.

For a description of the code generation settings available from the Service Editor, please refer the to Code Generation tab of the Project Editor.

The New Named Query window is for specifying the name of the named query and the data access object that will contain the named query.

The Overview tab is used for providing a description of the named query, navigating to the files generated from the named query, and navigating to the other Named Query configuration tabs. Refer to the following figure and table for details on this tab.

The Inputs/Outputs tab defines the input and output parameters of a particular named query. When this query is invoked, the consumer of the name query is required to map variables to the input and output parameters. Refer to the following figure and table for details on this tab.

The Query Text tab defines the query in either SQL or JPQL.Refer to the following figure and table for details on this tab.

The Spring Bean Configuration tab is used to configure the scope and @Transaction annotations for the Named Query. Refer to the following figure and table for details on this tab.

The New Exception window is for specifying the name of the exception and the model package that will contain the exception.

The Overview tab is used for providing a description of the Exception, navigating to the files generated from the Exception, and navigating to the other Exception configuration tabs. Refer to the following figure and table for details on this tab.

The Code Generation tab is for configuring the generation options for an Exception. This tab shows you all the code artifacts that are generated and managed by the Spring DSL Exception. Each entry in this table represents a code artifact that is generated for the Exception. In addition to enabling and disabling code generation on an artifact-by-artifact basis, you can also customize the name of the artifact, the package used, and the location where the artifact is generated to.

Code Generation

The code generation settings can be specified at the project level, which will control the code generation settings for the entire project. The code generation settings can also be customized for each artifact using the code generation tab from the respective editor for the artifact.

For a description of the code generation settings available from the Service Editor, please refer the to Code Generation tab of the Project Editor.

The New Model Package window is for specifying the name of the model package.

This panel is for configuring the Spring Code Generation properties of the current project.

This panel controls the code generation preferences of the current Eclipse workspace.

This panel controls the deployment preferences of the current Eclipse workspace.

This panel controls the modeling preferences of the current Eclipse workspace.

This panel controls the web flow diagram preferences of the current Eclipse workspace.