Partilhar via

Polimorfismo na estrutura de Atores Confiáveis

  • Artigo

A estrutura Reliable Actors permite que você construa atores usando muitas das mesmas técnicas que você usaria no design orientado a objetos. Uma dessas técnicas é o polimorfismo, que permite que tipos e interfaces herdem de pais mais generalizados. A herança na estrutura Reliable Actors geralmente segue o modelo .NET com algumas restrições adicionais. No caso do Java/Linux, segue o modelo Java.

Interfaces

A estrutura Reliable Actors requer que você defina pelo menos uma interface a ser implementada pelo seu tipo de ator. Essa interface é usada para gerar uma classe proxy que pode ser usada pelos clientes para se comunicar com seus atores. As interfaces podem herdar de outras interfaces, desde que cada interface implementada por um tipo de ator e todos os seus pais derivem de IActor(C#) ou Ator(Java). IActor(C#) e Ator(Java) são as interfaces base definidas pela plataforma para atores nos frameworks .NET e Java, respectivamente. Assim, o exemplo clássico de polimorfismo usando formas pode ser mais ou menos assim:

Hierarquia de interface para atores de forma

Tipos

Você também pode criar uma hierarquia de tipos de ator, que são derivados da classe Ator base fornecida pela plataforma. No caso de formas, você pode ter um tipo base Shape(C#) ou ShapeImpl(Java):

public abstract class Shape : Actor, IShape
{
    public abstract Task<int> GetVerticeCount();

    public abstract Task<double> GetAreaAsync();
}

public abstract class ShapeImpl extends FabricActor implements Shape
{
    public abstract CompletableFuture<int> getVerticeCount();

    public abstract CompletableFuture<double> getAreaAsync();
}

Subtipos de Shape(C#) ou ShapeImpl(Java) podem substituir métodos da base.

[ActorService(Name = "Circle")]
[StatePersistence(StatePersistence.Persisted)]
public class Circle : Shape, ICircle
{
    public override Task<int> GetVerticeCount()
    {
        return Task.FromResult(0);
    }

    public override async Task<double> GetAreaAsync()
    {
        CircleState state = await this.StateManager.GetStateAsync<CircleState>("circle");

        return Math.PI *
            state.Radius *
            state.Radius;
    }
}

@ActorServiceAttribute(name = "Circle")
@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
public class Circle extends ShapeImpl implements Circle
{
    @Override
    public CompletableFuture<Integer> getVerticeCount()
    {
        return CompletableFuture.completedFuture(0);
    }

    @Override
    public CompletableFuture<Double> getAreaAsync()
    {
        return (this.stateManager().getStateAsync<CircleState>("circle").thenApply(state->{
          return Math.PI * state.radius * state.radius;
        }));
    }
}

Observe o ActorService atributo no tipo de ator. Esse atributo informa à estrutura Reliable Ator que ela deve criar automaticamente um serviço para hospedar atores desse tipo. Em alguns casos, você pode querer criar um tipo base que se destina exclusivamente ao compartilhamento de funcionalidade com subtipos e nunca será usado para instanciar atores concretos. Nesses casos, você deve usar a abstract palavra-chave para indicar que nunca criará um ator com base nesse tipo.

Próximos passos