AWS Il servizio di modernizzazione del mainframe (esperienza Managed Runtime Environment) non è più aperto a nuovi clienti. Per funzionalità simili a AWS Mainframe Modernization Service (esperienza Managed Runtime Environment), esplora AWS Mainframe Modernization Service (Self-Managed Experience). I clienti esistenti possono continuare a utilizzare il servizio normalmente. [Per ulteriori informazioni, consulta AWS Modifica della disponibilità di Mainframe Modernization.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html) Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Cosa sono i semplificatori di dati in AWS Transform for mainframe Nei sistemi mainframe e midrange (denominati nel seguente argomento come sistemi «legacy»), i linguaggi di programmazione più utilizzati come COBOL PL/I o RPG forniscono un accesso di basso livello alla memoria. Questo accesso si concentra sul layout della memoria a cui si accede tramite tipi nativi, ad esempio suddivisi in zone, compressi o alfanumerici, possibilmente anche aggregati tramite gruppi o array. In un determinato programma coesiste una combinazione di accessi a un determinato pezzo di memoria, tramite entrambi i campi digitati e come accesso diretto ai byte (memoria grezza). Ad esempio, i programmi COBOL passeranno gli argomenti ai chiamanti come insiemi di byte contigui (LINKAGE) o i read/write dati dei file nello stesso modo (record), interpretando tali intervalli di memoria con campi digitati organizzati in quaderni. Tali combinazioni di accesso grezzo e strutturato alla memoria, il ricorso a un layout di memoria preciso a livello di byte e tipi legacy, ad esempio suddivisi in zone o compressi, sono funzionalità che non sono né nativamente né facilmente disponibili nell'ambiente di programmazione Java. Come parte della soluzione AWS Transform for mainframe per modernizzare i programmi legacy in Java, la libreria **Data Simplifier** fornisce tali costrutti ai programmi Java modernizzati e li espone in un modo il più familiare possibile agli sviluppatori Java (getters/setter, array di byte, basati su classi). È una dipendenza fondamentale del codice Java modernizzato generato da tali programmi. Per semplicità, la maggior parte delle spiegazioni seguenti si basa su costrutti COBOL, ma è possibile utilizzare la stessa API sia PL1 per la modernizzazione del layout dei dati RPG, poiché la maggior parte dei concetti è simile. **Topics** + [Classi principali](#ba-shared-data-main-classes) + [Associazione e accesso ai dati](#ba-shared-data-binding-access) + [FQN dei tipi Java discussi](#ba-shared-data-fqn) ## Classi principali Per facilitare la lettura, questo documento utilizza i nomi brevi Java delle interfacce e delle classi dell'API AWS Transform for mainframe. Per ulteriori informazioni, consulta [FQN dei tipi Java discussi](#ba-shared-data-fqn). ### Rappresentazione della memoria a basso livello Al livello più basso, la memoria (un intervallo contiguo di byte accessibile in modo rapido e casuale) è rappresentata dall'interfaccia. `Record` Questa interfaccia è essenzialmente un'astrazione di un array di byte di dimensione fissa. In quanto tale, fornisce setter e getter in grado di accedere o modificare i byte sottostanti. ### Rappresentazione strutturata dei dati Per rappresentare dati strutturati, come «01 elementi di dati» o «01 quaderni», come si trovano in COBOL DATA DIVISION, vengono utilizzate le sottoclassi della `RecordEntity` classe. Normalmente non sono scritti a mano, ma generati dagli strumenti di modernizzazione AWS Transform for mainframe a partire dai costrutti legacy corrispondenti. È comunque utile conoscerne la struttura principale e l'API, in modo da capire come vengono utilizzati dal codice di un programma modernizzato. Nel caso di COBOL, quel codice è Java generato dalla relativa PROCEDURE DIVISION. Il codice generato rappresenta ogni «elemento di dati 01" con una `RecordEntity` sottoclasse; ogni campo elementare o aggregato che lo compone è rappresentato come un campo Java privato, organizzato come un albero (ogni elemento ha un elemento principale, tranne quello principale). A scopo illustrativo, ecco un esempio di elemento di dati COBOL, seguito dal corrispondente codice generato da AWS Transform for mainframe che lo modernizza: ``` 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); } } ``` #### Campi elementari I campi di classe `Elementary` (o`Filler`, se senza nome) rappresentano una «foglia» della struttura dei dati preesistente. Sono associati a un intervallo contiguo di byte sottostanti («intervallo») e di solito hanno un tipo (possibilmente parametrizzato) che esprime come interpretare e modificare tali byte (rispettivamente «decodificando» e «codificando» un valore in un array di byte). from/to Tutti i tipi elementari sono `RangeType` sottoclassi di. I tipi più comuni sono: | Tipo COBOL | Tipo di semplificatore di dati | | --- | --- | | `PIC X(n)` | `AlphanumericType` | | `PIC 9(n)` | `ZonedType` | | `PIC 9(n) COMP-3` | `PackedType` | | `PIC 9(n) COMP-5` | `BinaryType` | #### Campi aggregati I campi aggregati organizzano il layout di memoria del loro contenuto (altri aggregati o campi elementari). Essi stessi non hanno un tipo elementare. `Group`i campi rappresentano campi contigui in memoria. Ciascuno dei campi contenuti è disposto nello stesso ordine in memoria, il primo campo è in offset `0` rispetto alla posizione del campo del gruppo in memoria, il secondo campo è in `0 + (size in bytes of first field)` offset, ecc. Vengono utilizzati per rappresentare sequenze di campi COBOL nello stesso campo contenitore. `Union`i campi rappresentano più campi che accedono alla stessa memoria. Ciascuno dei campi contenuti è disposto in modo offset `0` rispetto alla posizione del campo unionale in memoria. Vengono ad esempio utilizzati per rappresentare il costrutto COBOL «REDEFINES» (i primi figli dell'Unione sono l'elemento di dati ridefinito, i secondi figli ne sono la prima ridefinizione, ecc.). I campi array (sottoclassi di`Repetition`) rappresentano la ripetizione, in memoria, del layout del loro campo figlio (sia esso un aggregato stesso o un elemento elementare). Presentano un determinato numero di tali layout secondari in memoria, ognuno dei quali è in posizione sfalsata. `index * (size in bytes of child)` Sono usati per rappresentare i costrutti COBOL «OCCURS». #### Primitive In alcuni casi di modernizzazione, i «primitivi» possono essere utilizzati anche per presentare elementi di dati «root» indipendenti. Sono molto simili nell'uso `RecordEntity` ma non provengono da esso, né si basano su codice generato. Vengono invece forniti direttamente dal runtime AWS Transform for mainframe come sottoclassi dell'`Primitive`interfaccia. Esempi di tali classi fornite sono `Alphanumeric` o. `ZonedDecimal` ## Associazione e accesso ai dati L'associazione tra dati strutturati e dati sottostanti può essere effettuata in diversi modi. Un'interfaccia importante a questo scopo è quella `RecordAdaptable` che viene utilizzata per ottenere `Record` una «visualizzazione scrivibile» dei dati `RecordAdaptable` sottostanti. Come vedremo di seguito, vengono `RecordAdaptable` implementate più classi. Allo stesso modo, AWS Transform per mainframe APIs e il codice che manipola la memoria di basso livello (come argomenti dei programmi, I/O record di file, area di comunicazione CICS, memoria allocata...) spesso si aspettano un come handle per quella memoria. `RecordAdaptable` Nel caso della modernizzazione COBOL, la maggior parte degli elementi di dati è associata alla memoria, che verrà fissata durante la durata dell'esecuzione del programma corrispondente. A tal fine, `RecordEntity` le sottoclassi vengono istanziate una sola volta in un oggetto principale generato (il programma Context) e si occuperanno di istanziare le sottoclassi, in base alla `Record` dimensione dei byte. `RecordEntity` In altri casi COBOL, come l'associazione di elementi LINKAGE agli argomenti del programma o la modernizzazione del costrutto SET ADDRESS OF, un'istanza deve essere associata a un oggetto fornito. `RecordEntity` `RecordAdaptable` A tal fine, esistono due meccanismi: + se l'`RecordEntity`istanza esiste già, il `RecordEntity.bind(RecordAdaptable)` metodo (ereditato da`Bindable`) può essere usato per fare in modo che questa istanza «punti» a questo`RecordAdaptable`. Qualsiasi getter o setter chiamato su `RecordEntity` verrà quindi supportato (lettura o scrittura di byte) dai byte sottostanti. `RecordAdaptable` + se deve essere istanziato, `RecordEntity` è disponibile un costruttore generato che accetta a. `RecordAdaptable` Al contrario, è possibile accedere ai dati `Record` attualmente associati ai dati strutturati. Per questo, `RecordEntity` implementa`RecordAdaptable`, quindi `getRecord()` può essere chiamato su qualsiasi istanza del genere. Infine, molti verbi COBOL o CICS richiedono l'accesso a un singolo campo, per scopi di lettura o scrittura. La `RangeReference` classe viene utilizzata per rappresentare tale accesso. Le sue istanze possono essere ottenute dai `getXXXReference()` metodi `RecordEntity` generati (ovvero `XXX` il campo a cui si accede) e passate ai metodi di runtime. `RangeReference`viene in genere utilizzato per accedere a interi `RecordEntity` o`Group`, mentre la sua sottoclasse `ElementaryRangeReference` rappresenta gli accessi ai campi. `Elementary` Si noti che la maggior parte delle osservazioni precedenti si applica alle `Primitive` sottoclassi, poiché si sforzano di implementare un comportamento simile a quello fornito dal runtime AWS Transform for mainframe (anziché dal codice generato). `RecordEntity` A tal fine, tutte le sottoclassi di `Primitive` implementano `RecordAdaptable` `ElementaryRangeReference` e `Bindable` interfacce in modo da essere utilizzabili al posto delle sottoclassi e `RecordEntity` dei campi elementari. ## FQN dei tipi Java discussi La tabella seguente mostra i nomi completi dei tipi Java discussi in questa sezione. | Nome breve | Nome completamente qualificato | | --- | --- | | `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` |