As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

O que são simplificadores de dados no AWS Blu Age

Em sistemas mainframe e midrange (referidos no tópico a seguir como sistemas “antigos”), as linguagens de programação usadas com frequência, como COBOL, PL/I ou RPG, fornecem acesso de baixo nível à memória. Esse acesso se concentra no layout de memória acessado por meio de tipos nativos, como zoneados, compactados ou alfanuméricos, possivelmente também agregados por meio de grupos ou matrizes.

Uma mistura de acessos a uma determinada parte da memória, por meio de campos digitados e como acesso direto a bytes (memória bruta), coexiste em um determinado programa. Por exemplo, os programas COBOL passarão argumentos para os chamadores como conjuntos contíguos de bytes (LINKAGE) ou lerão e gravarão dados de arquivos da mesma maneira (registros), enquanto interpretam esses intervalos de memória com campos digitados organizados em cadernos.

Essas combinações de acesso bruto e estruturado à memória, a dependência de um layout de memória preciso em nível de byte e tipos antigos, como zoneados ou compactados, são recursos que não estão disponíveis de forma nativa nem facilmente no ambiente de programação Java.

Como parte da solução AWS Blu Age para modernizar programas legados para Java, a biblioteca Data Simplifier fornece essas construções para programas Java modernizados e as expõe de uma forma que seja o mais familiar possível para os desenvolvedores Java (getters/setters, matrizes de bytes, baseadas em classes). É uma dependência central do código Java modernizado gerado a partir desses programas.

Para simplificar, a maioria das explicações a seguir é baseada em construções COBOL, mas você pode usar a mesma API para ambas PL1 e para a modernização do layout de dados de RPG, já que a maioria dos conceitos é semelhante.

Classes principais

Para facilitar a leitura, este documento usa os nomes abreviados Java das interfaces e classes da API AWS Blu Age. Para obter mais informações, consulte FQN dos tipos de Java discutidos.

Representação de baixo nível

No nível mais baixo, a memória (uma faixa contígua de bytes acessível de forma rápida e aleatória) é representada pela interface Record. Essa interface é essencialmente uma abstração de uma matriz de bytes de tamanho fixo. Dessa forma, ele fornece setters e getters capazes de acessar ou modificar os bytes subjacentes.

Representação de dados estruturados

Para representar dados estruturados, como “01 itens de dados” ou “01 cadernos”, conforme encontrado em COBOL DATA DIVISION, são usadas subclasses da RecordEntity classe. Normalmente, eles não são escritos à mão, mas gerados pelas ferramentas de modernização do AWS Blu Age a partir das construções legadas correspondentes. Ainda é útil conhecer sua estrutura principal e sua API, para que você possa entender como o código em um programa modernizado as usa. No caso do COBOL, esse código é gerado em Java a partir de sua DIVISÃO DE PROCEDIMENTOS.

O código gerado representa cada “01 item de dados” com uma RecordEntity subclasse; cada campo elementar ou agregado que o compõe é representado como um campo Java privado, organizado como uma árvore (cada item tem um pai, exceto o raiz).

Para fins ilustrativos, aqui está um exemplo de item de dados COBOL, seguido pelo código correspondente gerado pelo AWS Blu Age que o moderniza:

01 TST2.
 02 FILLER PIC X(4).
 02 F1     PIC 9(2) VALUE 42.
 02 FILLER PIC X.
 02        PIC 9(3) VALUE 123.
 02 F2     PIC X VALUE 'A'.

public class Tst2 extends RecordEntity {

	   private final Group root = new Group(getData()).named("TST2"); 
	   private final Filler filler = new Filler(root,new AlphanumericType(4));
	   private final Elementary f1 = new Elementary(root,new ZonedType(2, 0, false),new BigDecimal("42")).named("F1");
	   private final Filler filler1 = new Filler(root,new AlphanumericType(1));
	   private final Filler filler2 = new Filler(root,new ZonedType(3, 0, false),new BigDecimal("123"));
	   private final Elementary f2 = new Elementary(root,new AlphanumericType(1),"A").named("F2");
	

	   /**
	    * Instantiate a new Tst2 with a default record.
   	 * @param configuration the configuration
   	 */
	   public Tst2(Configuration configuration) {
		      super(configuration);
		      setupRoot(root);
	   }
	   /**
	    * Instantiate a new Tst2 bound to the provided record.
	    * @param configuration the configuration
	    * @param record the existing record to bind
	    */
	   public Tst2(Configuration configuration, RecordAdaptable record) {
		      super(configuration);
		      setupRoot(root, record);
	   }

	   /**
	    * Gets the reference for attribute f1.
	    * @return the f1 attribute reference
	    */
	   public ElementaryRangeReference getF1Reference() {
		      return f1.getReference();
	   }

	   /* *
	    * Getter for f1 attribute.
	    * @return f1 attribute
	    */
	   public int getF1() {
		      return f1.getValue();
	   }

	   /**
	    * Setter for f1 attribute.
	    * @param f1 the new value of f1
	    */
   	public void setF1(int f1) {
		      this.f1.setValue(f1);
	   }
	   /**
	    * Gets the reference for attribute f2.
	    * @return the f2 attribute reference
	    */
	   public ElementaryRangeReference getF2Reference() {
		      return f2.getReference();
	   }

	   /**
	    * Getter for f2 attribute.
	    * @return f2 attribute
	    */
	   public String getF2() {
		      return f2.getValue();
	   }

	   /**
	    * Setter for f2 attribute.
	    * @param f2 the new value of f2
	    */
	   public void setF2(String f2) {
		      this.f2.setValue(f2);
	   }
}

Campos elementares

Os campos de classe Elementary (ou Filler, quando não nomeados) representam uma “folha” da estrutura de dados antiga. Eles estão associados a uma extensão contígua de bytes subjacentes (“intervalo”) e geralmente têm um tipo (possivelmente parametrizado) que expressa como interpretar e modificar esses bytes (“decodificando” e “codificando”, respectivamente, um valor de/para uma matriz de bytes).

Todos os tipos elementares são subclasses de RangeType. Os tipos comuns são:

Agregar os campos

Os campos agregados organizam o layout de memória de seus conteúdos (outros agregados ou campos elementares). Eles próprios não têm um tipo elementar.

Campos de Group representam campos contíguos na memória. Cada um dos campos contidos é disposto na mesma ordem na memória, o primeiro campo está em deslocamento em 0 relação à posição do campo do grupo na memória, o segundo campo em deslocamento0 + (size in bytes of first field), etc. Eles são usados para representar sequências de campos COBOL sob o mesmo campo contendo.

Campos de Union representam vários campos acessando a mesma memória. Cada um dos campos contidos é disposto em deslocamento em 0 relação à posição do campo de união na memória. Eles são usados, por exemplo, para representar a estrutura COBOL “REDEFINES” (os primeiros filhos da União sendo o item de dados redefinido, os segundos filhos sendo sua primeira redefinição, etc.).

Os campos de matriz (subclasses de Repetition) representam a repetição, na memória, do layout de seu campo filho (seja um agregado em si ou um item elementar). Eles apresentam um determinado número desses layouts infantis na memória, cada um em offset index * (size in bytes of child). Eles são usados para representar estruturas COBOL “OCCURS”.

Primitivos

Em alguns casos de modernização, “Primitivos” também podem ser usados para apresentar itens de dados “raiz” independentes. Eles são muito semelhantes em uso a RecordEntity, mas não herdam dele, nem são baseados no código gerado. Em vez disso, eles são fornecidos diretamente pelo tempo de execução do AWS Blu Age como subclasses da Primitive interface. Exemplos dessas aulas fornecidas são Alphanumeric ou ZonedDecimal.

Vinculação e acesso a dados

A associação entre dados estruturados e dados subjacentes pode ser feita de várias maneiras.

Uma interface importante para esse propósito é RecordAdaptable a que é usada para obter Record uma “visão gravável” dos dados RecordAdaptable subjacentes. Como veremos abaixo, várias classes são implementadasRecordAdaptable. Reciprocamente, o AWS Blu Age APIs e o código que manipula a memória de baixo nível (como argumentos de programas, registros de E/S de arquivos, área de comunicação do CICS, memória alocada...) geralmente esperam um como um identificador para essa memória. RecordAdaptable

No caso de modernização do COBOL, a maioria dos itens de dados está associada à memória, que será corrigida durante a vida útil da execução do programa correspondente. Para isso, as subclasses RecordEntity são instanciadas uma vez em um objeto principal gerado (o contexto do programa) e se encarregarão de instanciar o Record subjacente, com base no tamanho do byte de RecordEntity.

Em outros casos de COBOL, como associar elementos LINKAGE a argumentos do programa ou modernizar a estrutura SET ADDRESS OF, uma instância RecordEntity deve ser associada a um RecordAdaptable fornecido. Para isso, existem dois mecanismos:

Por outro lado, os dados Record atualmente vinculados aos dados estruturados podem ser acessados. Para isso, RecordEntity implementosRecordAdaptable, portanto, getRecord() podem ser chamados em qualquer instância desse tipo.

Finalmente, muitos verbos COBOL ou CICS exigem acesso a um único campo, para fins de leitura ou escrita. A RangeReference classe é usada para representar esse acesso. Suas instâncias podem ser obtidas a partir de métodos getXXXReference() gerados de RecordEntity (XXX sendo o campo acessado) e passadas para métodos de runtime. RangeReference normalmente é usado para acessar todo o RecordEntity ou Group, enquanto sua subclasse ElementaryRangeReference representa acessos aos campos Elementary.

Observe que a maioria das observações acima se aplica às Primitive subclasses, pois elas se esforçam para implementar um comportamento semelhante ao fornecido pelo RecordEntity tempo de execução do AWS Blu Age (em vez do código gerado). Para este propósito, todas as subclasses de Primitive implementam as interfaces RecordAdaptable, ElementaryRangeReference e Bindable de forma a serem utilizáveis no lugar das subclasses RecordEntity e dos campos elementares.

FQN dos tipos de Java discutidos

A tabela a seguir mostra os nomes totalmente qualificados dos tipos Java discutidos nesta seção.