Java Message类代码示例

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private void sendMessage() {
    final String messageText = messageTextBox.getText();
    if ("".equals(messageText)) {
        setStatus("message is mandatory");
        messageTextBox.setFocus(true);
        return;
    }
    setStatus("sending message from Errai Bus Client ...");

    MessageBuilder.createMessage()
            .toSubject("HelloWorldService")
            .withValue(messageText)
            .done()
            .repliesTo(new MessageCallback() {
                public void callback(Message message) {
                    setStatus("Response from server: " + message.get(String.class, MessageParts.Value));
                }
            })
            .sendNowWith(messageBus);
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private HasBusyIndicatorDefaultErrorCallback getRenameErrorCallback(final RenamePopUpPresenter.View renamePopupView,
                                                                    BusyIndicatorView busyIndicatorView) {
    return new HasBusyIndicatorDefaultErrorCallback(busyIndicatorView) {

        @Override
        public boolean error(final Message message,
                             final Throwable throwable) {
            if (fileAlreadyExists(throwable)) {
                hideBusyIndicator();
                renamePopupView.handleDuplicatedFileName();
                return false;
            }

            renamePopupView.hide();
            return super.error(message,
                               throwable);
        }
    };
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
public HasBusyIndicatorDefaultErrorCallback getCopyErrorCallback(final CopyPopUpPresenter.View copyPopupView,
                                                                 BusyIndicatorView busyIndicatorView) {
    return new HasBusyIndicatorDefaultErrorCallback(busyIndicatorView) {

        @Override
        public boolean error(final Message message,
                             final Throwable throwable) {
            if (fileAlreadyExists(throwable)) {
                hideBusyIndicator();
                copyPopupView.handleDuplicatedFileName();
                return false;
            }

            copyPopupView.hide();
            return super.error(message,
                               throwable);
        }
    };
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
@Override
public void acquireLock(final Path path,
                        final ParameterizedCommand<LockResult> parameterizedCommand) {

    vfsLockService.call(new RemoteCallback<LockResult>() {

                            @Override
                            public void callback(final LockResult result) {
                                parameterizedCommand.execute(result);
                            }
                        },
                        new BusErrorCallback() {

                            @Override
                            public boolean error(Message message,
                                                 Throwable throwable) {

                                logger.error("Error when trying to acquire lock for " + path.toURI(),
                                             throwable);
                                parameterizedCommand.execute(LockResult.error());
                                return false;
                            }
                        }).acquireLock(path);
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private void _lookupDataSet(DataSetLookup request,
                            final DataSetReadyCallback listener) {
    try {
        dataSetLookupServices.call(
                new RemoteCallback<DataSet>() {
                    public void callback(DataSet result) {
                        if (result == null) {
                            listener.notFound();
                        } else {
                            listener.callback(result);
                        }
                    }
                },
                new ErrorCallback<Message>() {
                    @Override
                    public boolean error(Message message,
                                         Throwable throwable) {
                        return listener.onError(new ClientRuntimeError(throwable));
                    }
                })
                .lookupDataSet(request);
    } catch (Exception e) {
        listener.onError(new ClientRuntimeError(e));
    }
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private void configureRepository() {
    assetManagementServices.call(new RemoteCallback<Long>() {
                                     @Override
                                     public void callback(Long taskId) {
                                         //view.displayNotification( "Repository Configuration Started!" );
                                     }
                                 },
                                 new ErrorCallback<Message>() {
                                     @Override
                                     public boolean error(Message message,
                                                          Throwable throwable) {
                                         ErrorPopup.showMessage("Unexpected error encountered : " + throwable.getMessage());
                                         return true;
                                     }
                                 }).configureRepository(projectContext.getActiveRepository().getAlias(),
                                                        projectContext.getActiveBranch(),
                                                        configureScreenPopupView.getDevBranch(),
                                                        configureScreenPopupView.getReleaseBranch(),
                                                        configureScreenPopupView.getVersion());
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
public void configureRepository(String repository,
                                String sourceBranch,
                                String devBranch,
                                String releaseBranch,
                                String version) {
    assetManagementServices.call(new RemoteCallback<Long>() {
                                     @Override
                                     public void callback(Long taskId) {
                                         view.displayNotification("Repository Configuration Started!");
                                     }
                                 },
                                 new ErrorCallback<Message>() {
                                     @Override
                                     public boolean error(Message message,
                                                          Throwable throwable) {
                                         errorPopup.showMessage("Unexpected error encountered : " + throwable.getMessage());
                                         return true;
                                     }
                                 }
    ).configureRepository(repository,
                          sourceBranch,
                          devBranch,
                          releaseBranch,
                          version);
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private void populateOrganizationalUnits() {
    //populate Organizational Units list box
    organizationalUnitService.call(new RemoteCallback<Collection<OrganizationalUnit>>() {
                                       @Override
                                       public void callback(final Collection<OrganizationalUnit> organizationalUnits) {
                                           view.addOrganizationalUnitSelectEntry();
                                           if (organizationalUnits != null && !organizationalUnits.isEmpty()) {
                                               for (OrganizationalUnit organizationalUnit : organizationalUnits) {
                                                   view.addOrganizationalUnit(organizationalUnit);
                                                   availableOrganizationalUnits.put(organizationalUnit.getName(),
                                                                                    organizationalUnit);
                                               }
                                           }
                                       }
                                   },
                                   new ErrorCallback<Message>() {
                                       @Override
                                       public boolean error(final Message message,
                                                            final Throwable throwable) {
                                           view.errorLoadOrganizationalUnitsFail(throwable);
                                           return false;
                                       }
                                   }).getOrganizationalUnits();
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
@Test
public void testRunScenarioFail() throws Exception {
    final TestRunFailedErrorCallback callback = mock(TestRunFailedErrorCallback.class);

    doReturn(true)
            .when(callback)
            .error(any(Message.class),
                   any(RuntimeException.class));
    doReturn(callback).when(editor).getTestRunFailedCallback();
    doThrow(new RuntimeException("some problem")).when(service).runScenario(anyString(),
                                                                            any(Path.class),
                                                                            any(Scenario.class));
    editor.onRunScenario();

    verify(callback).error(any(Message.class),
                           any(RuntimeException.class));
    verify(view).showBusyIndicator(TestScenarioConstants.INSTANCE.BuildingAndRunningScenario());
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
@Test
public void testRunAllScenariosFail() throws Exception {
    final TestRunFailedErrorCallback callback = mock(TestRunFailedErrorCallback.class);

    doReturn(true)
            .when(callback)
            .error(any(Message.class),
                   any(RuntimeException.class));
    doReturn(callback).when(editor).getTestRunFailedCallback();
    doThrow(new RuntimeException("some problem")).when(testService).runAllTests(anyString(),
                                                                                any(Path.class));
    editor.onRunAllScenarios();

    verify(callback).error(any(Message.class),
                           any(RuntimeException.class));
    verify(view).showBusyIndicator(TestScenarioConstants.INSTANCE.BuildingAndRunningScenarios());
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private void search( String dataSource,
                     String schema,
                     String databaseObjectType,
                     String searchTerm,
                     InitializeCallback initializeCallback ) {
    clear( );
    view.showBusyIndicator( translationService.getTranslation(
            DataSourceManagementConstants.DatabaseObjectExplorerViewImpl_loadingDbObjects ) );
    metadataService.call( getSearchSuccessCallback( initializeCallback ),
            new HasBusyIndicatorDefaultErrorCallback( view ) {
                @Override
                public boolean error( Message message, Throwable throwable ) {
                    boolean result = super.error( message, throwable );
                    if ( initializeCallback != null ) {
                        initializeCallback.onInitializeError( throwable );
                    }
                    return result;
                }
            } ).findTables( dataSource,
            schema, buildSearchTerm( searchTerm ), buildSearchType( view.getObjectType() ) );
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private void loadSchemas( String dataSourceUuid, InitializeCallback initializeCallback ) {
    clear( );
    view.showBusyIndicator( translationService.getTranslation(
            DataSourceManagementConstants.DatabaseSchemaExplorerViewImpl_loadingDbSchemas ) );
    metadataService.call( new RemoteCallback< DatabaseMetadata >( ) {
        @Override
        public void callback( DatabaseMetadata metadata ) {
            view.hideBusyIndicator( );
            loadSchemas( metadata.getSchemas( ) );
            if ( initializeCallback != null ) {
                initializeCallback.onInitializeSuccess( );
            }
        }
    }, new HasBusyIndicatorDefaultErrorCallback( view ) {
        @Override
        public boolean error( Message message, Throwable throwable ) {
            boolean result = super.error( message, throwable );
            if ( initializeCallback != null ) {
                initializeCallback.onInitializeError( throwable );
            }
            return result;
        }
    } ).getMetadata( dataSourceUuid, false, true );
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
public void importRepository() {
    final String repositoryUrl = view.getRepositoryURL();
    if (isEmpty(repositoryUrl)) {
        view.showError(view.getEmptyRepositoryURLValidationMessage());
        return;
    }

    view.showBusyIndicator(view.getLoadingMessage());
    libraryService.call((Set<ExampleProject> projects) -> {
                            view.hideBusyIndicator();
                            view.hide();
                            libraryPlaces.goToImportProjects(null);
                            importProjectsSetupEvent.fire(new ImportProjectsSetupEvent(projects));
                        },
                        new DefaultErrorCallback() {
                            @Override
                            public boolean error(final Message message,
                                                 final Throwable throwable) {
                                view.hideBusyIndicator();
                                view.showError(view.getNoProjectsToImportMessage());
                                return false;
                            }
                        }).getProjects(repositoryUrl,
                                       view.getUserName(),
                                       view.getPassword());
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
private void verifyShowHide(boolean positive) {
    when(serviceCaller.call(any(RemoteCallback.class),
                            any(ErrorCallback.class)))
            .thenAnswer(new LoadContentAnswer(importsService,
                                              importsContent,
                                              positive ? null : errorCallback));

    presenter.init(path,
                   placeRequest);
    verify(view).showLoading();

    if (positive) {
        verify(view).hideBusyIndicator();
    } else {
        verify(errorCallback).error(any(Message.class),
                                    any(Throwable.class));
    }
}
 

import org.jboss.errai.bus.client.api.messaging.Message; //导入依赖的package包/类
protected void getDataTypes() {

        final String simpleDataTypes = "Boolean:Boolean,Float:Float,Integer:Integer,Object:Object,String:String";
        MessageBuilder.createCall(
                new RemoteCallback<List<String>>() {
                    public void callback(List<String> dataTypes) {
                        String formattedDataTypes = formatDataTypes(dataTypes);
                        String allDataTypes = simpleDataTypes + "," + formattedDataTypes;
                        showDataIOEditor(allDataTypes.toString());
                    }
                },
                new BusErrorCallback() {
                    public boolean error(Message message,
                                         Throwable t) {
                        notification.fire(new NotificationEvent(StunnerFormsClientFieldsConstants.INSTANCE.Error_retrieving_datatypes(),
                                                                NotificationEvent.NotificationType.ERROR));
                        showDataIOEditor(simpleDataTypes);
                        return false;
                    }
                },
                DataTypesService.class).getDataTypeNames();
    }