com.asayama.gwt.angular.client

Interface Module

All Superinterfaces:

com.google.gwt.core.client.EntryPoint

All Known Implementing Classes:

AbstractModule, NG

public interface Module
extends com.google.gwt.core.client.EntryPoint

Provides GWT Java interface for AngularJS's Module object, and acts as an adapter for GWT module (represented by the EntryPoint interface) and Angular module (represented by the added interfaces in this class.

http://docs.angularjs.org/api/angular.Module

An Angular module represents a set of Angular components, such as controllers, services, filters, and directives. In and of itself, module component does not offer any added functionality. The task of registering various components relevant to the module is done by implementing the onModuleLoad() method.

It is recommended the code to be organized such that a single GWT module represents a single Angular module. This will help the code organized, and easier to understand, though this is not strictly enforced by the code. More advanced users may create separate sets of GWT and Angular module hierarchies and assemble them any way he wishes.

If you choose to mirror the GWT and Angular modules, then be sure to register your implementation of your Module to the GWT module descriptor as an entry point, e.g. com/example/app/MyModule.gwt.xml

<?xml version="1.0" encoding="UTF-8"?>
 <module>
   <inherits name="com.google.gwt.user.User" />
   <inherits name="com.asayama.gwt.angular.NG" />
   <source path="client" />
   <entry-point class="com.example.app.client.MyModule" />
 </module>
 

The corresponding MyModule class definition may look like

 // In this hypothetical example, the module consists of a constant named
 // "pages", directive named "myHello", filter named "reverse", and two
 // controllers, "com.exmaple.client.FooController" and 
 // "com.example.client.BarController".
 
 package com.example.app.client;
 
 public class MyModule extends AbstractModule {
   public void onModuleLoad() {
     Angular.module(this);
     constant("pages", JSArray.create(new String[]{
       "Introduction", "Theory", "Design", "Implementation", 
       "Test Methods", "Test Results", "Analysis", "Reference"
     }));
     directive(MyHello.class);
     filter(Reverse.class);
     controller(FooController.class);
     controller(BarController.class);
   }
 }
 

Note that this module focuses on registering the components into a single module, and is not concerned with building the user interface. The work of building the user interface (or bootstrapping) should be the job of a GWT module, and it is recommended that this is separated from the rest of the Angular module hierarchy. For example, com/example/ui/MyEntryPoint.gwt.xml

<?xml version="1.0" encoding="UTF-8"?>
 <module>
   <inherits name="com.google.gwt.user.User" />
   <inherits name="com.example.app.MyModule" />
   <source path="client" />
   <entry-point class="com.example.ui.client.MyEntryPoint" />
 </module>
 

The corresponding MyEntryPoint class definition may look like

 package com.example.ui.client;
 
 public class MyEntryPoint extends EntryPoint {
   public void onModuleLoad() {
     Angular.bootstrap();
   }
 }
 

If you follow this code organization convention, then the module dependency declared with <inherits> statements in *.gwt.xml files will be consistent with the Angular module dependency (i.e. "requires" property in AngularJS). You should have only one entry point that bootstraps the user interface per application.

Users should consider extending AbstractModule rather than directly implementing this interface.

Author:

kyoken74

See Also:

AbstractModule

Method Summary

Methods

Modifier and Type	Method and Description
void	bind(com.asayama.gwt.angular.client.JSModule jso) This method is used to bind the underlying AngularJS module object to the Java wrapper.
<P extends Provider<?>> Module	config(Class<P> klass, Configurator<P> configurator) Configures a provider prior to obtaining the factory from it.
Module	constant(String name, Object value) Defines a value as a service to the module.
<C extends Controller> Module	controller(Class<C> klass) Registers a controller component with the module.
<D extends Directive> Module	directive(Class<D> klass) Registers a directive component with the module.
<S extends Service> Module	factory(Class<S> klass) Deprecated. Replaced by service(Class)
<S extends Service> Module	factory(Factory<S> factory) Registers a service object factory with the module, so that the service object is created if/when it is requested.
<F extends Filter> Module	filter(Class<F> klass) Registers a filter component with the module.
String	getName() Returns the name of the module.
void	onModuleLoad()
<S extends Service> Module	service(Class<S> klass) Registers a service class with the module, so that the service object is created if/when it is requested.
<S extends Service> Module	service(S service) Registers a service object with the module.
Module	value(String name, Object value) Defines a value as a service to the module.

Method Detail

onModuleLoad

void onModuleLoad()

Specified by:

onModuleLoad in interface com.google.gwt.core.client.EntryPoint

bind

void bind(com.asayama.gwt.angular.client.JSModule jso)

This method is used to bind the underlying AngularJS module object to the Java wrapper.

• https://github.com/kyoken74/gwt-angular/issues/64

getName

String getName()

Returns the name of the module. Every Angular module must be registered with Angular framework, and give a name at the time of the registration. This ensures that only one instance of the module per name exists at runtime. See Angular class methods for more details.

value

Module value(String name,
           Object value)

Defines a value as a service to the module.

Parameters:

name - Name by which to register the value with Injector

value - Value object to register with Injector

Returns:

Value object registered with Injector

constant

Module constant(String name,
              Object value)

Defines a value as a service to the module.

Parameters:

name - Name by which to register the value with Injector

value - Value object to register with Injector

Returns:

Value object registered with Injector

filter

<F extends Filter> Module filter(Class<F> klass)

Registers a filter component with the module. The name of the component is derived from the class name, e.g.

 // Derived name is "myFilter". Java package is omitted.
 filter(com.example.MyFilter.class);
 

directive

<D extends Directive> Module directive(Class<D> klass)

Registers a directive component with the module. The name of the component is derived from the class name, e.g.

 // Derived name is "myDirective". Java package is omitted.
 // Attribute directive usage is <div data-my-directive> 
 // Class directive usage is <div class="my-directive"> 
 // Element directive usage is <my-directive> 
 directive(com.example.MyDirective.class);
 

service

<S extends Service> Module service(S service)

Registers a service object with the module. This method should be used when the instance of the service already exists, so there is no benefit to deferring the instantiation of the object.

service

<S extends Service> Module service(Class<S> klass)

Registers a service class with the module, so that the service object is created if/when it is requested. This method is equivalent to

 factory(new DefaultFactory(com.example.MyService.class));
 

factory

@Deprecated
<S extends Service> Module factory(Class<S> klass)

Deprecated. Replaced by service(Class)

Deprecated since 0.0.68

factory

<S extends Service> Module factory(Factory<S> factory)

Registers a service object factory with the module, so that the service object is created if/when it is requested. The method is useful if the service creation needs customization/configuration, e.g. the creation of the service depends on other resources. If you merely wish to create an object via new or GWT.create(), then there is a convenience method service(Class).

config

<P extends Provider<?>> Module config(Class<P> klass,
                                    Configurator<P> configurator)

Configures a provider prior to obtaining the factory from it. Use the Configurator to configure the provider injected into the module.

Parameters:

klass - Provider to be configured.

configurator - Configures the provider.

controller

<C extends Controller> Module controller(Class<C> klass)

Registers a controller component with the module. The name of the component is derived from the class name, e.g.

 // Derived name is "com.example.MyController".
 factory(com.example.MyController.class);