Transformacoes de Modelos

Prévia do material em texto

1 
Transformações de Modelos 
Franklin Ramalho 
Universidade Federal de Campina Grande - 
UFCG 
 DDM- UFCG 
2 
Agenda 
• Motivação e Contexto 
• Transformações de Modelos 
• Técnicas de transformações 
– Exemplos 
• Requisitos para uma Linguagem de transformação 
• Linguagens 
– Java 
– Flora 
– XSLT 
– QVT 
– ATL 
Detalhadas na aula de hoje 
Detalhadas nas próximas aulas 
 DDM- UFCG 
3 
Transformações para quê? 
• CIM -> PIM -> PSM; PSM -> Código 
• Código -> PSM; PSM -> PIM; PIM -> PSM 
• CIM-> CIM; PIM -> PIM; PSM -> PSM; Código -> Código 
• Refinamento de modelos 
• Refatoramento de modelos 
• Engenharia reversa 
• Geração de visões 
• Derivação de produtos em uma linha de produtos 
• Geração de código 
• Migração de tecnologias 
• Execução de leis de transformação em geral 
 DDM- UFCG 
4 
Tipos de Modelos 
Modelo de requisitos: 
Define o domínio onde o 
sistema será desenvolvido, 
serviços e entidades 
envolvidas 
Modelo de análise e 
Projeto: define a 
arquitetura do sistema 
Modelo de realização: 
define como o sistema é 
desenvolvido 
Código do sistema 
[Fig. Blanc] 
 DDM- UFCG 
5 
Transformação entre modelos 
PIM 
PSM PSM 
code code 
CIM 
transformação 
transformação 
transformação 
transformação transformação 
transformação 
transformação 
transformação 
transformação 
transformação 
 DDM- UFCG 
6 
MDA - Ciclo de Vida 
requisitos 
análise 
testes 
CIM 
PIM 
código 
PSM 
 
Transformações 
PIM-PSM 
 
TOOL 
 
Transformações 
PSM-código 
 
TOOL 
A 
U 
T 
O 
M 
A 
T 
 I 
C 
A 
 
Processo 
Iterativo 
PIM parcial 
 
Transformações 
CIM-PIM 
 
TOOL 
2 
 DDM- UFCG 
7 
Arquitetura MDA 
Aplicação 
Engenho de 
transformação 
Engenho de 
transformação 
Engenho de 
transformação 
Definições de 
transformação 
Rule 
X{...} 
Definições de 
transformação 
Rule 
X{...} 
Definições de 
transformação 
Rule 
X{...} 
PIM PSM 
Código CIM 
Meta- 
mo delo 
Meta- 
mo delo 
MOF 
 DDM- UFCG 
8 
Transformação entre modelos 
• Grande esforço é empregado nas transformações 
 
• Regra de transformação: descrição de como um ou mais 
elementos do modelo fonte pode ser transformado em 
um ou mais elementos do modelo destino 
 
• Definição de transformação: conjunto de regras que 
juntas descrevem como um modelo fonte é 
transformado em um modelo destino 
 
• Linguagem de transformação: Linguagem na qual as 
definições de transformações são escritas 
 DDM- UFCG 
9 
Transformação entre modelos 
PIM PSM code 
• Podem ocorrer transformações entre linguagens idênticas: 
– Refactoring (modelo ou código) 
– Normalização (modelos E-R) 
Definições de 
 transformação 
Definições de 
 transformação 
Engenho de 
transformação 
Engenho de 
transformação 
[Fig., Kleppe et al.] 
 DDM- UFCG 
10 
Transformação de Modelos 
• Transformação de modelos não são transformações 
semânticas 
 DDM- UFCG 
11 
Transformação entre modelos 
• Técnicas de transformação de modelos: 
– Baseada em programação 
• Transformações de modelos são programas OO 
• Interfaces de manipulação (reflexiva e sob encomenda) 
 
– Baseada em templates 
• Transformações de modelos são templates 
• Escritos em uma linguagem dedicada 
• Parâmetros determinam o modelo destino 
 
– Baseada em modelos 
• Transformações são modelos de transformações 
 DDM- UFCG 
12 
Baseada em programação 
Programa 
Fidelidade 
Programa 
Fidelidade 
EJB 
UML EJB API 
UML 
API 
EJB 
Programa 
Java 
read write 
[Blanc, 2005] 
3 
 DDM- UFCG 
13 
Baseada em templates 
Programa 
Fidelidade 
Programa 
Fidelidade EJB 
UML EJB 
Interpretador 
Template 
UML2EJB
Template 
[Blanc, 2005] 
 DDM- UFCG 
14 
Baseada em modelos 
Programa 
Fidelidade 
Programa 
Fidelidade 
EJB 
UML EJB 
Programa 
 
Modelo ATL 
ATL 
 DDM- UFCG 
15 
Estudo de Caso 
 DDM- UFCG 
16 
Meta-modelo simplificado para UML 
 DDM- UFCG 
17 
Meta-modelo simplificado para 
Esquemas relacionais de BD 
 DDM- UFCG 
18 
UML2BD 
1. Todo pacote UML corresponde a um esquema 
2. Toda classe dentro de um pacote UML corresponde à 
uma tabela do esquema relacional 
3. Toda propriedade de uma classe corresponde à uma 
coluna dentro da tabela 
• Se o tipo da propriedade é uma classe UML, a coluna deve ser 
uma chave estrangeira 
• Se o tipo da propriedade é um tipo de dados UML, a coluna é 
do tipo correspondente 
4. Todo tipo de dados UML dentro de um pacote 
apresenta um tipo de dados correspondente dentro do 
esquema 
4 
 DDM- UFCG 
19 
Transformação baseada em programação 
• Linguagem: Java 
 
• Framework provendo interfaces: EMF 
 
• Necessário: Transformar meta-modelos MOF em Ecore 
 
• Aplicação das regras de geração de interfaces 
 DDM- UFCG 
20 
Interfaces geradas p/ meta-modelo UML 
• UMLPackage – obtido a partir da EClass UMLPackage 
– getElements() 
 
• Classifier – obtido a partir da EClass Classifier 
– getName() 
– setName() 
 
• Class – obtido a partir da EClass Class 
– getProps() 
– getName() 
– setName() 
 DDM- UFCG 
21 
Interfaces geradas p/ meta-modelo UML 
• DataType – obtido a partir da EClass DataType 
– getName() 
– setName() 
 
• Property – obtido a partir da EClass Property 
– getName() 
– setName() 
– getType() 
– setType() 
 
• UMLFactory – obtido a partir da EPackage UML 
– createClass(), createUMLPackage(), createProperty(), 
etc. 
 DDM- UFCG 
22 
Interfaces geradas p/ meta-modelo BD 
• Schema – obtido a partir da EClass Schema 
– getTables() 
 
• Table – obtido a partir da EClass Table 
– getColumns() 
– setColumns() 
 
• Column – obtido a partir da EClass Colums 
– getType() 
– setType() 
– getName() 
– setName() 
 DDM- UFCG 
23 
Interfaces geradas p/ meta-modelo BD 
• Type – obtido a partir da EClass Type 
– getName() 
– setName() 
 
• ForeignKey – obtido a partir da EClass ForeignKey 
– getRefTable() 
– setRefTable() 
 
• BDFactory – obtido a partir da EPackage BD 
– createSchema(), createTable(), createColumn(), etc. 
 DDM- UFCG 
24 
Transformação baseada em programação 
public void UMLPackage2Schema(UMLPackage pc){ 
Schema sh = BDFactoryImpl.eINSTANCE.createSchema(); 
for (Iterator it = pc.getElements().iterator(); it.hasNext();){ 
 Object next = it.next(); 
 if ( next instanceOf uml.Class) { 
 sh.getTables().add(Class2Table((uml.Class) next)); 
 } 
 else if (next instanceOf DataType) { 
 dataType2Type((DataType) next); 
 } 
} 
} 
Mapeando um pacote UML para um esquema relacional 
[Blanc, 2005] 
5 
 DDM- UFCG 
25 
Transformação baseada em programação 
public Table Class2Table(uml.Class c){ 
Table tab = BDFactoryImpl.eINSTANCE.createTable(); 
tab.setName(c.getName());for (Iterator it = c.getProps().iterator(); it.hasNext();){ 
 Property next = (Property) it.next(); 
 tab.getColumns().add(property2Column(next)); 
} 
ClassTable.put(c, tab); 
if (keyRef.containsKey(c)){ 
 Vector keys = (Vector) keyRef.get(c); 
 for (Iterator it = keys.iterator(); it.hasNext();){ 
 ForeignKey current = (ForeignKey) it.next(); 
 current.setRefTable(tab) 
 } 
} 
return tab; 
} 
Mapeando uma classe UML para uma tabela relacional 
[Blanc, 2005] 
 DDM- UFCG 
26 
Transformação baseada em programação 
public Column Property2Column(Property prop){ 
if (prop.getType() instanceOf uml.Class){ 
 ForeignKey key = BDFactoryImpl.eINSTANCE.createForeignKey(); 
 key.setName(prop.getName()); 
 if (ClassTable.containsKey(prop.getType())) { 
 key.setRefTable((Table) classTable.get(prop.getType))) 
 } 
 else{ 
 if (keyRef.containsKey(prop.getType())) 
 ((Vector) keyRef.get(prop.getType())).add(key); 
 else { 
 ((Vector vec = new Vector(); 
 vec.add(key); 
 keyRef.put(prop.getType(), vec); 
 } 
 } 
 return key; 
} 
Mapeando uma propriedade de uma classe UML 
 para uma coluna de uma tabela relacional 
[Blanc, 2005] 
 DDM- UFCG 
27 
Transformação baseada em programação 
else{ //Datatype 
 Column col = BDFactoryImpl.eINSTANCE.createColumn(); 
 col.setName(prop.getName()); 
 if (datatypeType.containsKey(prop.getType())) 
 col.setType((Type) datatypeType.get(prop.getType())); 
 else { 
 if (colType.containsKey(prop.getType())) 
 ((Vector) keyRef.get(prop.getType())).add(col); 
 else{ 
 ((Vector vec = new Vector(); 
 vec.add(col); 
 colType.put(prop.getType(), vec); 
 } 
 } 
 return col; 
} 
} 
Mapeando uma propriedade de uma classe UML 
para uma coluna de uma tabela relacional (cont.) 
 
[Blanc, 2005] 
 DDM- UFCG 
28 
Transformação baseada em programação 
public Type dataType2Type(DataType dt){ 
Type t = BDFactoryImpl.eINSTANCE.createType(); 
t.setName(dt.getName()); 
datatypeType.put(dt, t); 
if (colType.containsKey(dt)){ 
 Vector keys = (Vector) colType.get(dt); 
 for (Iterator it = keys.iterator(); it.hasNext();){ 
 Column current = (Column) it.next(); 
 current.setType(t); 
 } 
} 
return t; 
} 
Mapeando um tipo de dados UML para um tipo de 
dados em um esquema relacional 
[Blanc, 2005] 
 DDM- UFCG 
29 
Transformação baseada em templates 
• Transformações parametrizadas 
 
• Templates são definidos sobre o modelo destino 
 
• Parâmetros são substituídos por informação contida 
nos modelos fonte 
<Name> 
<n:type> 
 DDM- UFCG 
30 
Transformação baseada em templates 
<tables name=“<%clazz.getName()%>”> 
 <%for (Iterator it = clazz.getPropos().iterator(); it.hasNext();){ 
 Property next = (Property) it.next(); %> 
 <columns name = “<%next.getName()%>”> 
 <type name = “<%next.getType().getName()%>”> 
 <columns> 
 <%}%> 
</tables> 
Mapeando uma classe UML para uma tabela relacional 
6 
 DDM- UFCG 
31 
Baseada em modelos 
rule Class2Table { 
 from 
 c : UML!Class 
 to 
 t : DB!Table ( 
 name <- c.name, 
 ) 
} 
 
 DDM- UFCG 
32 
Transformação entre modelos 
• Características desejáveis em uma linguagem de transformação: 
 
– Linguagem de consulta 
– Linguagem para definição de transformações 
– Sintaxe abstrata 
– Sintaxe concreta 
– Ser declarativo 
– Ser imperativo 
– Operar sobre modelos 
 
– Bidirecional 
– Rastreamento 
– Suporte ao reuso e extensão 
– Suporte à transformações transacionais 
– Suporte a dados adicionais 
– Harmonia 
– Consistência incremental 
– Semântica formal 
– Executável 
OMG classifica 
Como obrigatórios 
 DDM- UFCG 
33 
Linguagens de Transformação 
• Baseada em programação 
– Java 
– Flora 
 
• Baseada em templates 
– XSLT 
 
• Baseada em modelos 
– ATL 
– QVT 
 DDM- UFCG 
34 
XSLT 
• XSL foi projetada para definir a formatação e 
apresentação de documentos XML 
 
• Este processo consiste de dois estágios: 
– Transformação Estrutural – os dados são convertidos de uma 
estrutura do documento XML para uma outra estrutura de saída. 
– Formatação – um formato requerido (HTML, PDF, p.e.) é 
aplicado à árvore resultado 
 
• Os estágios de transformação estrutural e de formatação 
foram reconhecidos como independentes, o que fez com 
que XSL fosse dividida em: 
– XSLT (eXtensible Stylesheet Language: Tranformations) – para 
definição das transformações 
– XSL-FO (XSL Formatting Objects) para formatação 
 DDM- UFCG 
35 
XSLT 
 
• XSLT é uma linguagem projetada para transformar um 
documento XML em outro documento XML 
– Transformar um elemento XML 
– Adicionar novos elementos 
– Remover elementos 
– Gerar texto 
 
• XSLT transforma uma árvore origem em uma árvore 
resultado 
 
• Padrão publicado pela W3C 
 DDM- UFCG 
36 
Documento 
Fonte 
XSL 
Processor 
Documento 
Destino 
XSLT 
Stylesheet 
XSLT 
7 
 DDM- UFCG 
37 
XSLT 
• Linguagem declarativa 
– Você descreve a transformação que deseja, ao invés de prover 
uma seqüência de instruções procedimentais 
 
• XSLT é essencialmente uma “ferramenta” para 
transformar documentos XML 
 
• XSLT manipula árvores 
 
 DDM- UFCG 
38 
XSLT 
• Elemento raiz de um documento XSL é <xsl:stylesheet> ou 
<xsl:transform> 
<xsl:stylesheet version=“1.0” 
xmlns:xsl=http://www.w3.org/1999/XSL/Transform> 
<?xml version=“1.0” encoding=ISO-8859-1”?> 
<xsl:stylesheet version=“1.0” xmlns:xsl=http://www.w3.org/1999/XSL/Transform> 
 <xsl:template match=“”> 
 corpo do template 
 </xsl:template> 
 … 
 <xsl:template match=“”> 
 corpo do template 
 </xsl:template> 
</xsl:sylesheet> 
• Documento XSL: Cabeçalho XML + <xsl:stylesheet> ou 
<xsl:transform> + Conjunto de regras de template 
 DDM- UFCG 
39 
XSLT 
• O processo de transformação é baseado em um conjunto 
de regras de template 
– Cada regra é composta de um padrão e uma ação. 
– Cada uma descreve como um elemento deve ser processado 
– Não existe uma ordem pré-definida 
– Não têm que casar a ordem de entrada com a ordem de saída 
– São definidas a partir do elemento <xsl:template>, que possui o 
atributo match para associar o template com um elemento XML. 
 
 <xsl:template match=“title”> 
 ... 
 </xsl:template> 
 <xsl:template match=“/”> 
 ... 
 </xsl:template> 
 
 DDM- UFCG 
40 
XSLT 
• O corpo das regras de template é constituído por: 
– Expressões XPath 
– Elementos XSLT 
– Funções XSLT e XPath 
 
• Manipular partes de um documento 
 
• Fazer a ligação de um documento com o outro 
 
• Duas formas de utilizar um arquivo xsl: 
– Através de uma linha de comando, que referencia os documentos 
envolvidos na transformação (p.e, o xml origem, o html resultado e 
o xslt) 
– Incluindo uma referência no próprio arquivo xml 
 DDM- UFCG 
41 
XSLT - Transformações 
XML 
Documento 1 
XMLS 
Documento 1 
Valido 
XSLT 
Document 
Engenho 
XSLT 
 
XML 
Documento 2 
XMLS 
Documento 2 
Valido 
 DDM- UFCG 
42 
XSLT 
<model xmlns:uml="http://www.eclipse.org/uml2/1.0.0/UML"xmlns:xmi="http://www.omg.org/XMI"> 
 <package id="pck1" name=“library"> 
 <class id="c1" name="Book"> 
 <association aggregationType="composite" id="c1_ass1" name="chapters" 
targetClass="c2"/> 
 <attribute cardinality="1..1" id="c1_atr1" name="title" type="dt1"/> 
 </class> 
 <class id="c2" name="Chapter"> 
 <attribute cardinality="1..1" id="c2_atr1" name="nbPages" type="dt2"/> 
 <attribute cardinality="1..1" id="c2_atr2" name="title" type="dt1"/> 
 <attribute cardinality="1..1" id="c2_atr3" name="author" type="dt1"/> 
 <association aggregationType="none" id="c2_ass1" name="book" 
 targetClass="c1"/> 
 </class> 
 </package> 
</model> 
Source file: book.xmi 
[Teles e Teixeira] 
8 
 DDM- UFCG 
43 
eXtensible Stylesheet Language 
Transformation (XSLT) 
<model xmlns:uml="http://www.eclipse.org/uml2/1.0.0/UML" 
xmlns:xmi="http://www.omg.org/XMI"> 
 <package id="pck1" name=“library"> 
 <class id="c1" name="Publication"> 
 <attribute cardinality="1..1" id="c1_atr1" name="title" type="dt1"/> 
 <attribute cardinality="1..1" id="c1_atr2" name="nbPages" type="dt2"/> 
 <attribute cardinality="1..1" id="c1_atr3" name="authors" type="dt1"/> 
 </class> 
 <datatype id="dt1" name="String"/> 
 <datatype id="dt2" name="Integer"/> 
 </package> 
</model> 
Target file: publication.xmi 
[Teles e Teixeira] 
 DDM- UFCG 
44 
eXtensible Stylesheet Language 
Transformation (XSLT) 
<?xml version="1.0" encoding="UTF-8"?> 
<xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" > 
 <xsl:output method="xml" /> 
 <xsl:template match=“class" > 
 … 
 <xsl:variable name="title" select="@title" /> 
 <xsl:variable name="authors" select="concat(@chapters.author, ',')"/> 
 <xsl:variable name="nbPages" select="sum(@chapters.nbPages)"/> 
 
 <xsl:call-template name="createPublication"> 
 <xsl:with-param name="title" select="$title"/> 
 <xsl:with-param name="authors" select="$authors"/> 
 < xsl:with-param name="nbPages" select="$nbPages"/> 
 </xsl:call-template> 
 </xsl:template> 
</xsl:transform> 
XSLT file: book2Publicartion.xslt 
[Teles e Teixeira] 
 DDM- UFCG 
45 
Linguagens de transformação 
JMI FLORA XSLT QVT ATL 
Concisão X X X 
Linguagens conhecidas X X +- +- 
Eficiência X X ? X 
Executável X X X +- X 
Expressiva X X X X 
Meta-modelo X X X X X 
Semântica Formal X +- +- 
Padrão X X +- 
Conceitos OO/MOF X X X X 
Ferramentas X X X X X 
 DDM- UFCG 
46 
Referências e Bibliografia 
• OMG Specifications. http://www.omg.org 
 
• MDA explained (The model-driven architecture: practice and 
promise). Kleppe, A., Warmer, J. and Bast, W. Object-
Technology Series. Addison-Wesley. 2003. 
 
• MDA en action (Ingénérie logicielle guidée par les modèles). 
Blanc, X. Eyrolles. 2005.