Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Que sont les simplificateurs de données dans AWS Blu Age

Sur les systèmes mainframe et de milieu de gamme (appelés systèmes « anciens » dans la rubrique suivante), les langages de programmation fréquemment utilisés tels que COBOL, PL/I ou RPG fournissent un accès de bas niveau à la mémoire. Cet accès se concentre sur la disposition de la mémoire accessible via des types natifs tels que zonée, compressée ou alphanumérique, éventuellement agrégée via des groupes ou des tableaux.

Un mélange d'accès à un élément de mémoire donné, à la fois via des champs dactylographiés et sous forme d'accès direct aux octets (mémoire brute), coexiste dans un programme donné. Par exemple, les programmes COBOL transmettent des arguments aux appelants sous forme d'ensembles d'octets contigus (LINKAGE) ou lisent et écrivent des données à partir de fichiers de la même manière (enregistrements), tout en interprétant ces plages de mémoire à l'aide de champs typés organisés dans des cahiers.

Ces combinaisons d'accès brut et structuré à la mémoire, le recours à une disposition précise de la mémoire au niveau des octets et les types existants, tels que zoné ou compressé, sont des fonctionnalités qui ne sont ni nativement ni facilement disponibles dans l'environnement de programmation Java.

Faisant partie de la solution AWS Blu Age pour moderniser les anciens programmes vers Java, la bibliothèque Data Simplifier fournit de telles constructions aux programmes Java modernisés et les expose d'une manière aussi familière que possible aux développeurs Java (getters/setters, tableaux d'octets, basés sur des classes). Il s'agit d'une dépendance essentielle du code Java modernisé généré à partir de tels programmes.

Pour des raisons de simplicité, la plupart des explications suivantes sont basées sur des constructions COBOL, mais vous pouvez utiliser la même API pour les deux PL1 et pour la modernisation de la mise en page des données RPG, car la plupart des concepts sont similaires.

Classes principales

Pour faciliter la lecture, ce document utilise les noms abrégés Java des interfaces et des classes de l'API AWS Blu Age. Pour de plus amples informations, veuillez consulter FQN des types Java discutés.

Représentation de la mémoire de bas niveau

Au niveau le plus bas, la mémoire (une plage contiguë d'octets accessible de manière rapide et aléatoire) est représentée par l'Recordinterface. Cette interface est essentiellement une abstraction d'un tableau d'octets de taille fixe. En tant que tel, il fournit des setters et des getters capables d'accéder aux octets sous-jacents ou de les modifier.

Représentation de données structurées

Pour représenter des données structurées, telles que « 01 éléments de données » ou « 01 copybooks », comme on le trouve dans COBOL DATA DIVISION, des sous-classes de la RecordEntity classe sont utilisées. Ils ne sont généralement pas écrits à la main, mais générés par les outils de modernisation de AWS Blu Age à partir des anciennes constructions correspondantes. Il est toujours utile de connaître leur structure principale et leur API afin de comprendre comment le code d'un programme modernisé les utilise. Dans le cas de COBOL, ce code est généré par Java à partir de leur DIVISION PROCEDURE.

Le code généré représente chaque « 01 élément de données » avec une RecordEntity sous-classe ; chaque champ élémentaire ou agrégat qui le compose est représenté sous la forme d'un champ Java privé, organisé sous forme d'arbre (chaque élément a un parent, à l'exception de la racine).

À des fins d'illustration, voici un exemple d'élément de données COBOL, suivi du code généré par AWS Blu Age correspondant qui le modernise :

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);
	   }
}

Domaines élémentaires

Les champs de classe Elementary (ouFiller, lorsqu'ils ne sont pas nommés) représentent une « feuille » de l'ancienne structure de données. Ils sont associés à une plage contiguë d'octets sous-jacents (« plage ») et ont généralement un type (éventuellement paramétré) indiquant comment interpréter et modifier ces octets (en « décodant » et en « codant » respectivement une valeur depuis/vers un tableau d'octets).

Tous les types élémentaires sont des sous-classes de. RangeType Les types courants sont les suivants :

Champs agrégés

Les champs d'agrégation organisent la disposition en mémoire de leur contenu (autres agrégats ou champs élémentaires). Ils n'ont pas eux-mêmes de type élémentaire.

Grouples champs représentent des champs contigus en mémoire. Chacun de leurs champs contenus est disposé dans le même ordre en mémoire, le premier champ étant 0 décalé par rapport à la position du champ de groupe en mémoire, le second champ étant décalé0 + (size in bytes of first field), etc. Ils sont utilisés pour représenter des séquences de champs COBOL sous le même champ conteneur.

Unionles champs représentent plusieurs champs accédant à la même mémoire. Chacun de leurs champs contenus est disposé de manière 0 décalée par rapport à la position du champ d'union en mémoire. Ils sont par exemple utilisés pour représenter la construction COBOL « REDEFINES » (les premiers enfants de l'Union étant l'élément de données redéfini, les seconds étant sa première redéfinition, etc.).

Les champs matriciels (sous-classes deRepetition) représentent la répétition, en mémoire, de la disposition de leur champ enfant (qu'il s'agisse d'un agrégat lui-même ou d'un élément élémentaire). Ils mettent en mémoire un certain nombre de mises en page pour enfants de ce type, chacune étant index * (size in bytes of child) décalée. Ils sont utilisés pour représenter les constructions COBOL « SURCIS ».

Primitives

Dans certains cas de modernisation, les « primitives » peuvent également être utilisées pour présenter des éléments de données « racines » indépendants. Leur utilisation est très similaire, RecordEntity mais ils ne proviennent pas de celui-ci et ne sont pas basés sur le code généré. Au lieu de cela, ils sont directement fournis par le moteur d'exécution AWS Blu Age en tant que sous-classes de l'Primitiveinterface. Des exemples de ces cours fournis sont Alphanumeric ouZonedDecimal.

Liaison des données et accès

L'association entre les données structurées et les données sous-jacentes peut se faire de différentes manières.

Une interface importante à cette fin est RecordAdaptable celle qui est utilisée pour obtenir une Record « vue inscriptible » des données RecordAdaptable sous-jacentes. Comme nous le verrons ci-dessous, plusieurs classes sont implémentéesRecordAdaptable. Réciproquement, AWS Blu Age APIs et le code manipulant de la mémoire de bas niveau (tels que les arguments des programmes, les enregistrements d'E/S de fichiers, la zone de communication CICS, la mémoire allouée...) s'attendent souvent à un RecordAdaptable identifiant pour cette mémoire.

Dans le cas de la modernisation COBOL, la plupart des éléments de données sont associés à une mémoire qui sera corrigée pendant la durée d'exécution du programme correspondant. À cette fin, les RecordEntity sous-classes sont instanciées une seule fois dans un objet parent généré (le programme Context) et se chargeront d'instancier leur sous-jacentRecord, en fonction de la taille en octets. RecordEntity

Dans d'autres cas COBOL, tels que l'association d'éléments LINKAGE à des arguments de programme ou la modernisation de la construction SET ADDRESS OF, une RecordEntity instance doit être associée à un paramètre fourni. RecordAdaptable Pour cela, deux mécanismes existent :

Inversement, les données Record actuellement liées aux données structurées sont accessibles. Pour celaRecordAdaptable, RecordEntity implémente donc getRecord() n'importe quelle instance de ce type.

Enfin, de nombreux verbes COBOL ou CICS nécessitent l'accès à un seul champ, à des fins de lecture ou d'écriture. La RangeReference classe est utilisée pour représenter un tel accès. Ses instances peuvent être obtenues à partir de getXXXReference() méthodes RecordEntity générées (XXXétant le champ accédé) et transmises aux méthodes d'exécution. RangeReferenceest généralement utilisé pour accéder à l'ensemble RecordEntity ouGroup, tandis que sa sous-classe ElementaryRangeReference représente les accès aux Elementary champs.

Notez que la plupart des observations ci-dessus s'appliquent aux Primitive sous-classes, car elles visent à implémenter un comportement similaire à celui fourni par le moteur d'exécution AWS Blu Age (au lieu du code généré). RecordEntity À cette fin, toutes les sous-classes d'Primitiveimplémentent ElementaryRangeReference et RecordAdaptable les Bindable interfaces de manière à être utilisables à la fois à la place des RecordEntity sous-classes et des champs élémentaires.

FQN des types Java discutés

Le tableau suivant indique les noms complets des types Java décrits dans cette section.