Dans les appels distants, les paramètres et les valeurs de retour doivent être transmis sur le réseau. Cette utilisation nécessite la sérialisation pour convertir l'objet en flux d'octets, puis le désérialiser en un objet d'un bout à l'autre.
Puisqu'il y a un article précédent mentionnant Hessian, nous allons ici parler brièvement de la différence entre la sérialisation Java et la sérialisation Hessian.
Tout d'abord, la sérialisation de la Hesse est beaucoup plus efficace que la sérialisation Java, et le flux d'octets généré est beaucoup plus court. Mais relativement parlant, la sérialisation Java n'est pas fiable, et elle n'est pas aussi complète que le support de sérialisation Java. La raison d'une telle différence est de regarder leur implémentation.
Parlons d'abord de la sérialisation de Java. Je ne parlerai pas du principe de travail spécifique. La sérialisation Java sérialisera les métadonnées et les données commerciales de la classe d'objets à sérialiser à partir du flux d'octets, et sérialisera toutes les choses dans toute la relation d'héritage. Le flux d'octets qu'il sérialise est une description complète de la structure de l'objet au contenu, contenant toutes les informations, il est donc moins efficace et le flux d'octet est relativement grand. Mais comme tout est en effet sérialisé, on peut dire que tout peut être transféré, il est donc également plus utilisable et fiable.
Quant à la sérialisation de la Hesse, son mécanisme de mise en œuvre consiste à se concentrer sur les données et à accompagner les informations de type simple. Tout comme entier A = 1, Hessian sérialisera en un flux comme I 1. Je représente Int ou Integer, et 1 est le contenu des données. Pour les objets complexes, via le mécanisme de réflexion Java, Hessian sérialise toutes les propriétés de l'objet en tant que carte, produisant un flux comme m className PropertyName1 i 1 PropertyName S StringValue (probablement, oubliez-le exactement), qui contient la description de base et le contenu des données. Pendant le processus de sérialisation, si un objet apparaît auparavant, Hessian insérera directement un bloc tel qu'un index R pour représenter une position de référence, éliminant ainsi le temps de sérialisation et de désérialisation à nouveau. Le prix de cela est que Hessian doit gérer les différents types différemment (donc Hessian est paresseux et ne prend pas en charge court), et il doit également gérer les opérations spéciales lors de la rencontre de certains objets spéciaux (comme StackTraceElement). Et en même temps, car il ne va pas profondément dans la mise en œuvre pour effectuer la sérialisation, il y aura certaines incohérences à certaines occasions, telles que les cartes obtenues par le biais de collections.SynchronizedMap.
La sérialisation fait référence à la sérialisation d'un objet dans un flux d'octets pour un stockage ou une transmission de réseau facile; Alors que la désérialisation est tout le contraire, la conversion du flux d'octet en un objet. Ce que nous utilisons habituellement, c'est la méthode de sérialisation Hessian et la méthode de sérialisation Java. L'efficacité et la taille de la sérialisation des deux méthodes de sérialisation sont différentes. À en juger par les résultats des tests, Hessian est meilleur. Voici un exemple de sérialisation Hessian (aucun fichier IO et IO réseau, sérialisation pure et désérialisation):
/ ** * Pure Hessian Serialization * @param objet * @return * @throws exception * / public static byte [] serialize (objet objet) exception {if (object == null) {lancez new nullpointerException ();} bytearrayoutStream os = new bytearrayoutStream (); hessianserializeroutUrut Hessianoutput = new HessianSerializerOutput (OS); HessianOutput.WriteObject (Object); return os.toByTearray ();} / ** * Pure Deserialization Hessian * @param bytes * @return * @throws exception * / bytes) NullPointerException ();} bytearrayInputStream est = new bytearrayInputStream (bytes); HessianserializerInput HessianInput = new HessianseRializerInput (IS); objet objet = HessianInput.readObject (); Return Object;}Une autre méthode courante est la sérialisation Java:
/ ** * Java Serialization * @param obj * @return * @throws exception * / public static byte [] serialize (objet obj) lève une exception {if (obj == null) lance un nouveau nullpointerException (); objectOutStream Out = new ObjectOutputStream (OS); out.writeObject (obj); return os.toBytearray ();} / ** * Java Desérialization * @param by * @return * @throws exception * / public static Deerialize (byte [] by) exception {if (by == Null) New NullpointerException (); byTearRay BytearrayInputStream (by); objectInputStream in = new ObjectInputStream (IS); return in.readObject ();}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.