Prática de Software: Primeiro exemplo com o Eclipse Modeling Framework (EMF)

No artigo anterior iniciámos a exploração do Eclipse EMF. Neste artigo vamos construir um modelo de domínio (modelo de dados persistentes) de um pequeno sistema de gestão de biblioteca.

Para começar, vamos criar um novo projeto:

- selecionar File --> New --> Project
- Depois, na janela que se abre, selecionar Eclipse Modeling Framework --> Empty EMF Project

Damos ao novo projeto o nome testemf.

Depois, no folder model, usar o botão do lado direito do rato,

e selecionarNew --> Other, abrindo-se a janela seguinte.

Aqui, selecionamos EcoreTools --> Ecore Diagram. O objetivo é criar um modelo de domínio usando o editor de diagramas de classes UML.

A criação do Ecore Diagram é uma maneira agradável de criar um modelo Ecore, instância do metamodelo Ecore, podendo, portanto, ser entendida como a criação de uma DSL (linguagem específica do domínio).Chamemos, então, LibraryModel à nossa DSL.

No editor de diagramas criamos o modelo de classes pretendido:

Para isso, arrastamos os elementos do metamodelo dos quais queremos criar instâncias, a partir da Pallete. Por exemplo, para criar a classe Book (instância de EClass) arrastamos o elemento EClass da Pallete, e atribuimos-lhe o nome Book. Para criar atributos arrastamos o elemento EAttribute, para a zona de atributos da classe, e assim sucessivamente.

Como pretendemos gerar código a partir do nosso diagrama, este deve ser completo. Devemos, por isso, atribuir tipos de dados a todos os atributos.

Para criar relações (associações) entre as classes, devemos arrastar da Pallete o elemento EReference. Uma relação, por defeito, é do tipo 1 para muitos e navegável nesse sentido, ou seja apenas o lado muito é referenciável. Nas propriedades (Properties) da relação podemos alterar o nome e a cardinalidade do atributo da relação.

Se pretendermos uma relação navegável em ambos os sentidos, temos que criar duas relações e identificar uma como oposta da outra.

Mais informação sobre edição de diagramas de classes neste editor pode ser obtida em:

- Eclipse Modeling Framework (EMF) - Tutorial

Mais informação sobre UML (Unified Modeling Language) pode ser obtida, por exemplo em:

- Capítulo 2. Fundamentos do UML

Ao criarmos o diagrama Ecore (LibraryModel.ecorediag), é criado automaticamente um modelo Ecore (LibraryModel.ecore) com a mesma informação.

A partir do modelo ecore, vamos criar um modelo para geração de código. Com o botão do lado direito do rato sobre o ficheiro do modelo ecore (LibraryModel.ecore), selecionamos New --> Other,

E, depois, selecionamos EclipseModelingFramework --> EMF Generator Model:

E escolhemos o model importer de Ecore model:

É criado o modelo LibraryModel.genmodel:

A partir deste modelo, vamos criar o código Java correspondente às classes do modelo inicial:

O projeto fica então com os seguintes ficheiros:

Foram criadas três packages Java:

        - LibraryModel - contém as interfaces correspondentes às classes do modelo, e a Factory que permite criar instâncias das classes.
        - LibraryModel.impl - contém as classes que implementam as interfaces.
        - LibraryModel.util - contém o AdapterFactory.

Vamos ver o código relativo à classe Author do nosso modelo:

- Author.java:

package LibraryModel;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;

public interface Author extends EObject {
    String getName();
    void setName(String value);
    String getSurname();
    void setSurname(String value);
    EList<Book> getBooks();
} // Author

- AuthorImpl.java:

package LibraryModel.impl;

import LibraryModel.Author;
import LibraryModel.Book;
import LibraryModel.LibraryModelPackage;
import java.util.Collection;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.EList;
...

public class AuthorImpl extends EObjectImpl implements Author {
    protected static final String NAME_EDEFAULT = null;
    protected String name = NAME_EDEFAULT;
    protected static final String SURNAME_EDEFAULT = null;
    protected String surname = SURNAME_EDEFAULT;
    protected EList<Book> books;

    protected AuthorImpl() {
        super();
    }

    @Override
    protected EClass eStaticClass() {
        return LibraryModelPackage.Literals.AUTHOR;
    }

    public String getName() {
        return name;
    }

    public void setName(String newName) {
        String oldName = name;
        name = newName;
        if (eNotificationRequired())
            eNotify(new ENotificationImpl(this, Notification.SET, LibraryModelPackage.AUTHOR__NAME, oldName, name));
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String newSurname) {
        String oldSurname = surname;
        surname = newSurname;
        if (eNotificationRequired())
            eNotify(new ENotificationImpl(this, Notification.SET, LibraryModelPackage.AUTHOR__SURNAME, oldSurname, surname));
    }

    public EList<Book> getBooks() {
        if (books == null) {
            books = new EObjectWithInverseResolvingEList.ManyInverse<Book>(Book.class, this, LibraryModelPackage.AUTHOR__BOOKS, LibraryModelPackage.BOOK__AUTHORS);
        }
        return books;
    }

. . .

    @Override
    public String toString() {
        if (eIsProxy()) return super.toString();

        StringBuffer result = new StringBuffer(super.toString());
        result.append(" (name: ");
        result.append(name);
        result.append(", surname: ");
        result.append(surname);
        result.append(')');
        return result.toString();
    }

} //AuthorImpl

Podemos criar a documentação relativa às classes geradas, usando o Javadoc. Para isso, no menu Project, selecionamos Generate Javadoc...: