AWS El servicio de modernización de mainframes (experiencia en entornos de ejecución gestionados) ya no está abierto a nuevos clientes. Para obtener prestaciones similares a las del Servicio de Modernización de AWS Mainframe (experiencia en entornos de ejecución gestionados), explore el Servicio de Modernización de AWS Mainframe (experiencia autogestionada). Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener más información, consulte Cambio en la disponibilidad de la modernización del [AWS mainframe.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html)
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# ¿Qué son los simplificadores de datos en AWS Blu Age?
En los sistemas de unidad central y de gama media (denominados en el siguiente tema sistemas “heredados”), los lenguajes de programación de uso frecuente, como COBOL, PL/I o RPG, proporcionan un acceso de bajo nivel a la memoria. Este acceso se centra en el diseño de la memoria, al que se accede mediante tipos nativos, como zonificados, empaquetados o alfanuméricos, y es posible que también se agreguen mediante grupos o matrices.
En un programa determinado coexiste una combinación de accesos a un determinado fragmento de memoria, a través de campos de tipos definidos y acceso directo a bytes (memoria sin procesar). Por ejemplo, los programas COBOL pasarán los argumentos a los iniciadores como conjuntos contiguos de bytes (LINKAGE), o leerán y escribirán datos de los archivos de la misma manera (registros), al tiempo que interpretarán dichos rangos de memoria con campos de tipos definidos organizados en cuadernos.
Estas combinaciones de acceso sin proceso y estructurado a la memoria, la dependencia de un diseño de memoria preciso a nivel de bytes y los tipos heredados, como zonificados o empaquetados, son características que no están disponibles de forma nativa ni son de fácil acceso en el entorno de programación Java.
Como parte de la solución de AWS Blu Age para modernizar los programas antiguos a Java, la biblioteca **Data Simplifier** proporciona estas construcciones a los programas Java modernizados y las expone de una manera que resulta lo más familiar posible para los desarrolladores de Java (captres/configuradores, matrices de bytes, basadas en clases). Se trata de una dependencia fundamental para el código Java modernizado generado a partir de esos programas.
Para simplificar, la mayoría de las siguientes explicaciones se basan en construcciones de COBOL, pero puede usar la misma API para la modernización del PL1 diseño de datos de RPG, ya que la mayoría de los conceptos son similares.
**Topics**
+ [Clases principales](#ba-shared-data-main-classes)
+ [Enlace y acceso a los datos](#ba-shared-data-binding-access)
+ [Nombres completos calificados de los tipos de Java descritos](#ba-shared-data-fqn)
## Clases principales
Para facilitar la lectura, en este documento se utilizan los nombres abreviados en Java de las interfaces y clases de la API de AWS Blu Age. Para obtener más información, consulte [Nombres completos calificados de los tipos de Java descritos](#ba-shared-data-fqn).
### Representación de la memoria de bajo nivel
En el nivel más bajo, la memoria (un rango contiguo de bytes al que se puede acceder de forma rápida y aleatoria) está representada por la interfaz de `Record`. Esta interfaz es esencialmente una abstracción de una matriz de bytes de un tamaño fijo. Como tal, proporciona setters y getters capaces de acceder o modificar los bytes subyacentes.
### Representación de datos estructurados
Para representar datos estructurados, como “01 elementos de datos” o “01 cuadernos”, como se encuentran en COBOL DATA DIVISION, se utilizan subclases de la clase `RecordEntity`. Por lo general, no se escriben a mano, sino que se generan con las herramientas de modernización de AWS Blu Age a partir de las correspondientes construcciones heredadas. Sigue siendo útil conocer su estructura principal y su API, para poder entender cómo los usa el código de un programa modernizado. En el caso de COBOL, ese código es Java generado a partir de su PROCEDURE DIVISION.
El código generado representa cada “01 elemento de datos” con una subclase `RecordEntity`; cada campo elemental o agregado que lo compone se representa como un campo Java privado, organizado en forma de árbol (cada elemento tiene un elemento principal, excepto el raíz).
A modo ilustrativo, he aquí un ejemplo de elemento de datos de COBOL, seguido del correspondiente código generado por AWS Blu Age que lo 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 elementales
Los campos de clase `Elementary` (o `Filler`, cuando no tienen nombre) representan una “hoja” de la estructura de datos heredada. Están asociados a un espacio contiguo de bytes subyacentes (“rango”) y, por lo general, tienen un tipo (posiblemente parametrizado) que expresa cómo interpretar y modificar esos bytes (mediante la “decodificación” y la “codificación”, respectivamente, de un valor desde/hacia una matriz de bytes).
Todos los tipos elementales son subclases de `RangeType`. Los tipos frecuentes son:
| Tipo COBOL | Tipo de Data Simplifier |
| --- | --- |
| `PIC X(n)` | `AlphanumericType` |
| `PIC 9(n)` | `ZonedType` |
| `PIC 9(n) COMP-3` | `PackedType` |
| `PIC 9(n) COMP-5` | `BinaryType` |
#### Campos agregados
Los campos agregados organizan el diseño de memoria de sus contenidos (otros agregados o campos elementales). No tienen un tipo elemental en sí mismos.
Los campos `Group` representan campos contiguos en la memoria. Cada uno de sus campos contenidos está dispuesto en el mismo orden en la memoria, el primer campo tiene un desplazamiento `0` con respecto a la posición del campo de grupo en la memoria, el segundo campo tiene un desplazamiento `0 + (size in bytes of first field)`, etc. Se utilizan para representar secuencias de campos COBOL en el mismo campo contenedor.
Los campos `Union` representan varios campos que acceden a la misma memoria. Cada uno de sus campos contenidos está dispuesto con un desplazamiento `0` con respecto a la posición del campo de unión en la memoria. Por ejemplo, se utilizan para representar el constructo COBOL “REDEFINE” (el primer elemento secundario de Union es el elemento de datos redefinido, el segundo elemento secundario es su primera redefinición, etc.).
Los campos matriciales (subclases de `Repetition`) representan la repetición, en la memoria, del diseño de su campo secundario (ya sea un agregado en sí mismo o un elemento elemental). Diseñan un número determinado de estos diseños secundarios en la memoria, cada uno de los cuales tiene un desplazamiento `index * (size in bytes of child)`. Se utilizan para representar los constructos “OCCURS” de COBOL.
#### Elementos primitivos
En algunos casos de modernización, los elementos primitivos también se pueden utilizar para presentar elementos de datos raíz independientes. Su uso es muy similar al de `RecordEntity`, pero no provienen de él ni se basan en el código generado. En su lugar, el motor de ejecución de AWS Blu Age los proporciona directamente como subclases de la interfaz. `Primitive` Algunos ejemplos de estas clases proporcionadas son `Alphanumeric` o`ZonedDecimal`.
## Enlace y acceso a los datos
La asociación entre los datos estructurados y los datos subyacentes se puede realizar de varias maneras.
Una interfaz importante para este propósito es `RecordAdaptable`, la cual se utiliza para obtener un `Record` que ofrece una “vista modificable” de los datos subyacentes de `RecordAdaptable`. Como veremos a continuación, varias clases implementan `RecordAdaptable`. Recíprocamente, AWS Blu Age APIs y la manipulación de código de memoria de bajo nivel (como argumentos de programas, registros de E/S de archivos, área de comunicación CICS, memoria asignada...) suelen esperar a `RecordAdaptable` como identificador para esa memoria.
En el caso de la modernización de COBOL, la mayoría de los elementos de datos están asociados a una memoria que permanecerá fija durante el tiempo de ejecución del programa correspondiente. Para ello, las subclases `RecordEntity` se instancian una vez en un objeto principal generado (el contexto del programa) y se encargan de instanciar su `Record` subyacente, en función del tamaño de bytes de `RecordEntity`.
En otros casos de COBOL, como cuando se asocian elementos LINKAGE a los argumentos del programa o se moderniza el constructo SET ADDRESS OF, una instancia `RecordEntity` debe estar asociada a un `RecordAdaptable` proporcionado. Para ello, existen dos mecanismos:
+ Si la instancia de `RecordEntity` ya existe, se puede usar el método `RecordEntity.bind(RecordAdaptable)` (heredado de `Bindable`) para hacer que esta instancia “apunte” a este `RecordAdaptable`. Cualquier getter o setter al que se invoque en `RecordEntity` estará respaldado (lectura o escritura de bytes) por los bytes del `RecordAdaptable` subyacente.
+ Si se va a crear una instancia de `RecordEntity`, hay disponible un constructor generado que acepte a `RecordAdaptable`.
Por el contrario, se puede acceder al `Record` actualmente vinculado a los datos estructurados. Para ello, `RecordEntity` implementa `RecordAdaptable`, por lo que se `getRecord()` puede invocar en cualquier instancia de este tipo.
Por último, muchos verbos de COBOL o CICS requieren acceso a un único campo para poder leerlos o escribirlos. La clase `RangeReference` se usa para representar dicho acceso. Sus instancias se pueden obtener a partir de los métodos `getXXXReference()` generados para `RecordEntity` (`XXX` es el campo al que se accede) y pasarlas a los métodos de tiempo de ejecución. `RangeReference` se utiliza normalmente para acceder a campos enteros `RecordEntity` o `Group`, mientras que su subclase `ElementaryRangeReference` representa los accesos a los campos `Elementary`.
Tenga en cuenta que la mayoría de las observaciones anteriores se aplican a `Primitive` las subclases, ya que se esfuerzan por implementar un comportamiento similar al que proporciona el `RecordEntity` tiempo de ejecución de AWS Blu Age (en lugar del código generado). Con este propósito, todas las subclases de `Primitive` implementan las interfaces `RecordAdaptable` `ElementaryRangeReference` y `Bindable` de modo que se puedan utilizar en lugar de las subclases `RecordEntity` y los campos elementales.
## Nombres completos calificados de los tipos de Java descritos
La siguiente tabla muestra los nombres completos calificados de los tipos de Java analizados en esta sección.
| Nombre corto | Nombre completo calificado |
| --- | --- |
| `Alphanumeric` | `com.netfective.bluage.gapwalk.datasimplifier.elementary.Alphanumeric` |
| `AlphanumericType` | `com.netfective.bluage.gapwalk.datasimplifier.metadata.type.AlphanumericType` |
| `BinaryType` | `com.netfective.bluage.gapwalk.datasimplifier.metadata.type.BinaryType` |
| `Bindable` | `com.netfective.bluage.gapwalk.datasimplifier.data.Bindable` |
| `Elementary` | `com.netfective.bluage.gapwalk.datasimplifier.data.structure.Elementary` |
| `ElementaryRangeReference` | `com.netfective.bluage.gapwalk.datasimplifier.entity.ElementaryRangeReference` |
| `Filler` | `com.netfective.bluage.gapwalk.datasimplifier.data.structure.Filler` |
| `Group` | `com.netfective.bluage.gapwalk.datasimplifier.data.structure.Group` |
| `PackedType` | `com.netfective.bluage.gapwalk.datasimplifier.metadata.type.PackedType` |
| `Primitive` | `com.netfective.bluage.gapwalk.datasimplifier.elementary.Primitive` |
| `RangeReference` | `com.netfective.bluage.gapwalk.datasimplifier.entity.RangeReference` |
| `RangeType` | `com.netfective.bluage.gapwalk.datasimplifier.metadata.type.RangeType` |
| `Record` | `com.netfective.bluage.gapwalk.datasimplifier.data.Record` |
| `RecordAdaptable` | `com.netfective.bluage.gapwalk.datasimplifier.data.RecordAdaptable` |
| `RecordEntity` | `com.netfective.bluage.gapwalk.datasimplifier.entity.RecordEntity` |
| `Repetition` | `com.netfective.bluage.gapwalk.datasimplifier.data.structure.Repetition` |
| `Union` | `com.netfective.bluage.gapwalk.datasimplifier.data.structure.Union` |
| `ZonedDecimal` | `com.netfective.bluage.gapwalk.datasimplifier.elementary.ZonedDecimal` |
| `ZonedType` | `com.netfective.bluage.gapwalk.datasimplifier.metadata.type.ZonedType` |