Solution

Grundlegende Anpassung > User Interface Customization > Presenting Information in the UI > Constructing and Rendering a Table Using the JSP Framework > Solution

Solution

Implement MVC table builders to create or convert a JCA table component.

Prerequisite knowledge

To achieve this objective, you need to have an understanding of the following JCA techniques:

• Data utilities

• GUI component

• Actions framework

• Configurable table views

• Java annotations

Solution Elements

Element	Type	Description
ComponentDataBuilder	Java interface	Creates the data model for the component
ComponentConfigBuilder	Java interface	Creates the configuration for the component
ConfigurableTableBuilder	Java interface	Creates the configurable table views for tables and trees
AbstractConfigurableTableBuilder	Java class	Base class that builders typically extend
ComponentConfig	Java interface	Base interface for component configurations
ComponentConfigFactory	Java interface	Creates ComponentConfig implementations
ComponentBuilder	Java annotation	Configures the component id used to look up a component builder

Procedure – Configuring Table Common Component

Creating a new Builder class

A table builder class corresponds to a table configuration. All the table-level as well as column-level properties should be configured in the builder class. When creating a new builder class, you should typically extend one of the abstract base classes provided by the MVC infrastructure:

• AbstractConfigurableTableBuilder

Use this base class if you are implementating a tree or table that supports configurable table views. This base class is located in the CoreHtmlComp module due to its dependency on the configurable table infrastructure.

• AbstractComponentBuilder

Use this base class for tables and trees that do not support configurable tables

• AbstractComponentConfigBuilder

Use this base class for info pages. You can also use this if you wish to separate your table or tree config builder from its data builder (not a typical use case).

• AbstractComponentDataBuilder

Use this base class for table and tree implementations where you have chosen to separate the config and data builder implementations (not a typical use case).

Implementing the ComponentConfigBuilder API

The table and column level configuration options can be specified by implementing ComponentConfigBuilder. ComponentConfigBuilder currently defines one method:

ComponentConfig buildComponentConfig(ComponentParams params);

The responsibility of this method roughly corresponds to what the describeTable tag does in 9.x versions.

The ComponentConfig hierarchy:

Using ComponentConfigFactory to get Table/column ComponentConfig objects

It is not necessary to create a ComponentConfig directly, instead use a ComponentConfigFactory. When extending the abstract base builder classes, the factory is available by calling getComponentConfigFactory(). When directly implementing ComponentConfigBuilder, also implement ComponentConfigFactoryAware. This will get you a reference to the factory when the builder is initialized.

Instance of TableConfig and ColumnConfig need to be used to specify table level and columns level customizations respectively. An example to get the TableConfig/ColumnConfig instance look like this:

ComponentConfigFactory factory = getComponentConfigFactory();
TableConfig table = factory.newTableConfig();
…
ColumnConfig col1 = factory.newColumnConfig(“column1Id”, false);
…
table.addComponent(col1);

Since column component is a nested component of table component, ColumnConfig can be added to the TableConfig using the addComponent() API as shown in above code snippet.

Setting properties on TableConfig and ColumnConfig:

Customization points available for the config classes are described in Customization Points. Refer to the JavaDoc for more details on the properties and capabilities of each config class.

Localizing your configs

To localize values within your config builder, the Mvc infrastructure provides a new ClientMessageSource class. If you are extending one of the abstract configuration base classes, then you can call getMessageSource(String) to create a message source for a given resource bundle class name. ClientMessageSource works like WTMessage, but ensures that the locale that you use is the client locale, rather than the locale that the server is running with.

Specifying the view JSP

Implementing the ComponentDataBuilder API

The data acquisition mechanism for table can be configured using ComponentDataBuilder interface. The data builder class needs to implement ComponentDataBuilder interface. ComponentDataBuilder currently defines one method:

Object buildComponentData(ComponentConfig config, ComponentParams params)

The responsibility of this method roughly corresponds to what the getModel/getIeModel tag do in JCA in the 9.x release stream.

Registering your ConfigurableTable

If your ComponentConfigBuilder implementation also implements ConfigurableTableBuilder, then you do not need to register your ConfigurableTable implementation in service.properties. You cannot register ConfigurableTableBuilder implementations themselves, independent from a ComponentConfigBuilder implementation.

Implementing your ConfigurableTable

You may choose to implement your ConfigurableTable as a static inner class of your builder, or to put it in a separate file. If you only intend to use it from within the builder implementation, then we recommend defining it as a private static inner class. An example:

public class MyTableBuilder extends AbstractConfigurableTableBuilder {
…
@Override
public ConfigurableTable buildConfigurableTable(String tableId) throws WTException {
return new MyConfigurableTable();
}

private static class MyConfigurableTable extends JCAConfigurableTable {
…
}
…
}

Configuring separate config and data builders

If you wish to implement your config and data builders in separate classes, then you must supply an additional ComponentBuilderType parameter to the @ComponentBuilder annotation.

For config builders, this looks like:

@ComponentBuilder(value=“my.component.id”,
type=ComponentBuilderType.CONFIG)
public class MyConfigBuilder implements ComponentConfigBuilder…

For data builders, this looks like:

@ComponentBuilder(value=“my.component.id”,
type=ComponentBuilderType.DATA)
public class MyDataBuilder implements ComponentDataBuilder…

If you wish to configure separate builders without using annotations, then the bean ids you choose must have the “.configBuilder” or “.dataBuilder” suffix. For example to configure a config builder, you would do the following:

Registering MVC builders

MVC builders can be registered using ComponentBuilder annotation or via explicit configuration, or by automated scanning. Automated scanning. After registering the table builders, the table component can be configured into the application in actions.xml just as JSP-based JCA components.

See MVC Components and Constructing and Rendering a Table Using the JSP Framework for more information on registering/configuring the table component.

Procedure – Configuring Table Common Component

Converting an Existing Table Implementation to MVC

Overview

This section describes the mapping of attributes from the 9.x legacy tags to the corresponding attributes on the new MVC table builders.

describeTable

The content of the describeTable tag is now specified in the buildComponentConfig method of ComponentConfigBuilder interface

JSP code was like this:

<jca:describeTable var="tableDescriptor" id="netmarkets_project_list"
configurable="true"
type="wt.projmgmt.admin.Project2" label="${projectListLabel}">

MVC code will look like this:

@ComponentBuilder(“netmarkets_project_list”)
public class ProjectListBuilder extends AbstractConfigurableTableBuilder {

@Override
public ComponentConfig buildComponentConfig(ComponentParams params) {
ComponentConfigFacory factory = getComponentConfigFactory();
TableConfig table = factory.newTableConfig();
table.setLabel(ClientMessage.get(RESOURCE,"PROJECT_LIST_NAME");
table.setType("wt.projmgmt.admin.Project2");
…
return table;
}

describeColumn

The content of the describeColumn tag is also specified in the buildComponentConfig method of ComponentConfigBuilder interface. As the column component is an child component of the table component, it is added to the table config.

JSP code was like this:

MVC code will look like this:

TableConfig table = factory.newTableConfig();
…
table.addComponent(factory.newColumnConfig(“name”,true));
table.addComponent(factory.newColumnConfig(“number”,false));
…

renderTable

The content of the renderTable tag is also specified in the buildComponentConfig method of ComponentConfigBuilder interface.

JSP code was like this:

<jca:renderTable showCustomViewLink="false" model="${tableModel}" showCount="true"
showPagingLinks="true" />

MVC code will look like this:

TableConfig table = factory.newTableConfig();
…
table.setShowCount(true);
table.setShowCustomViewLink(false);
…

getModel

The content of the getModel tag is specified in the buildComponentData method of ComponentDataBuilder interface.

JSP code was like this:

<jca:getModel var="tableModel" descriptor="${tableDescriptor}"
serviceName="com.ptc.netmarkets.projmgmt.ProjectCommands"
methodName="getProjects" ……. >
<jca:addServiceArgument value="${user}" type="wt.org.WTUser"/>
<jca:addServiceArgument value="${pseudoType}" type="java.lang.Integer"/>
</jca:getModel>

MVC code will look like this:

@Override
public QueryResult buildComponentData(ComponentConfig config,
ComponentParams params) {
WTPrincipal user = SessionHelper.getPrincipal();
return ProjectCommands.getProjects(user,0)
}

Parent topic

Constructing and Rendering a Table Using the JSP Framework

War dies hilfreich?