24 Soru: SerialVersionUID nedir ve neden kullanmalıyım?

tarafından oluşturulan soru Tue, Mar 17, 2015 12:00 AM

Eclipse, bir serialVersionUID eksik olduğunda uyarılar verir.

  

Serileştirilebilir sınıf Foo statik bir final bildirmedi   serialVersionUID uzun alan alanı

serialVersionUID nedir ve neden önemlidir? Lütfen, serialVersionUID'un kaybolmasının soruna neden olacağı bir örnek gösterin.

    
2767
24 Yanıtlar                              24                         

java.io.Serializable muhtemelen alabileceğiniz kadar iyi bir açıklama niteliğindedir:

  

Serileştirme çalışma zamanı, serileştirme sırasında serileştirilmiş bir nesnenin göndericisinin ve alıcısının serileştirmeyle uyumlu olan sınıfları yüklemiş olduğunu doğrulamak için serileştirme sırasında kullanılan serialVersionUID adlı bir sürüm numarasıyla ilişkilendirilir. Alıcı, karşılık gelen gönderenin sınıfından farklı bir serialVersionUID değerine sahip nesne için bir sınıf yüklediyse, seri kaldırma    InvalidClassException . Serileştirilebilir bir sınıf, serialVersionUID adında statik, son ve serialVersionUID türünde bir alan bildirerek kendi long'unu açıkça ilan edebilir:

 
ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
     

Serileştirilebilir bir sınıf açıkça bir serialVersionUID bildirmiyorsa, serileştirme çalışma zamanı, Java (TM) Nesne Serileştirme Belirtimi'nde açıklandığı gibi, sınıfın çeşitli yönlerine göre bu sınıf için varsayılan bir serialVersionUID değeri hesaplar. Bununla birlikte, varsayılan serialVersionUID hesaplaması, derleyici uygulamalarına bağlı olarak değişebilecek olan sınıf ayrıntılarına karşı son derece hassas olduğundan ve bu nedenle seri hale getirme sırasında beklenmedik serialVersionUID'a neden olabileceğinden, tüm seri hale getirilebilir sınıfların açıkça InvalidClassExceptions değerlerini açıklaması şiddetle tavsiye edilir . . Bu nedenle, farklı java derleyici uygulamalarında tutarlı bir serialVersionUID değerini garanti etmek için serileştirilebilir bir sınıfın açık bir serialVersionUID değeri bildirmesi gerekir. Ayrıca açık serialVersionUID beyannamelerin mümkün olan durumlarda özel değiştiriciyi kullanması şiddetle tavsiye edilir, çünkü bu beyanlar sadece ilan eden serialVersionUID sınıfı ilan edilen alanlar için geçerli değildir.

    
2111
2018-11-14 09: 45: 44Z
  1. Öyleyse, temelde söylediğiniz şey, eğer bir kullanıcı yukarıdaki tüm materyalleri anlamadıysa, söz konusu kullanıcının serileştirme konusunda endişe duymayacağını söyledi mi? "Nasıl?" Diye cevapladığına inanıyorum. "Neden?" açıklamak yerine. Birincisi, neden SerializableVersionUID ile rahatsız ettiğimi anlamıyorum.
    2009-01-01 07: 27: 10Z
  2. İkinci paragrafın nedeni: açıkça serialVersionUID değerini belirtmezseniz, otomatik olarak bir değer oluşturulur - ancak bu, derleyici uygulamasına bağlı olduğu için kırılgandır.
    2009-01-01 20: 26: 06Z
  3. Eclipse neden "özel statik son uzun serialVersionUID = 1L;" ifadesine ihtiyacım olduğunu söylüyor? Exception sınıfını genişlettiğimde ne zaman?
    2014-06-15 17: 12: 39Z
  4. @ JohnMerlino: Size ihtiyacın olduğunu bir tane olarak söylemesini beklemiyorum - ama olabilir olabilir İstisnaları doğru şekilde serileştirmenize yardımcı olması için Onları serileştirmeyecekseniz, gerçekten sabitine ihtiyacınız yoktur.
    2014-06-15 18: 43: 23Z
  5. @ JohnMerlino, sorunuzun nedenini cevaplamak için: İstisna, Seri hale getirilebilir ve eclipse, bir serialVersionUID belirlemediğiniz konusunda uyarır, ki bu iyi bir fikir olacaktır (sınıfı serileştirmek istemiyorsanız) kaçınmakJonSkeet'in yayınladığı sorunlar.
    2014-10-08 11: 48: 52Z

Sadece uygulamanın iyiliği için serileştirmeniz gerektiğinden serileştiriyorsanız (örneğin, HTTPSession için serileştirme umurunda olan) ), o zaman bunu görmezden gelebilirsiniz.

Gerçekten serileştirme kullanıyorsanız, yalnızca doğrudan serileştirmeyi kullanarak nesneleri kaydetmeyi ve almayı planlıyorsanız önemlidir. de-serializing, sınıf sürümünüzü temsil eder ve sınıfınızın geçerli sürümü önceki sürümüyle geriye dönük değilse, artırmalısınız.

Çoğu zaman, seri hale getirmeyi doğrudan kullanmayacaksınız. Bu durumda, hızlı düzeltme seçeneğini tıklatarak varsayılan bir serialVersionUID oluşturun ve bu konuda endişelenmeyin.

    
442
2019-02-24 07: 17: 24Z
  1. Kalıcı depolama için serileştirme kullanmıyorsanız, bir değer eklemek yerine @SuppressWarnings kullanmanız gerektiğini söyleyebilirim. Sınıfı daha az tutar ve sizi uyumsuz değişikliklerden korumak için serialVersionUID mekanizmasının sıklığını korur.
    2011-04-24 10: 43: 24Z
  2. Bir satırın (@SuppressWarnings ek açıklama) başka bir satıra (seri hale getirilebilir id) "sınıfın daha az kümeleşmesine" karşı nasıl eklenmiş olduğunu anlamıyorum. Kalıcı depolama için seri hale getirme kullanmıyorsanız, neden sadece "1" kullanmıyorsunuz? Bu durumda, otomatikleştirilmiş kimlik bilgisini zaten umursamazsınız.
    2011-04-25 17: 09: 46Z
  3. @ MetroidFan2002: @ TomAnderson'ın sizi uyumsuz değişikliklerden koruduğu SerialVersionUID puanının geçerli olduğunu düşünüyorum. serialVersionUID kullanarak, sınıfı kalıcı depolama için kullanmak istemiyorsanız, bu amaç daha iyi belgelenir.
    2011-12-30 14: 32: 05Z
  4. "Sınıfınızın şu anki sürümü önceki sürümüyle geriye dönük değilse, artırmalısınız:" İlk önce Serialization'ın kapsamlı nesne sürümlendirme desteğini araştırmalısınız, ( a) Sınıfın gerçekten şu anda seri hale getirme uyumsuz bir şekilde olduğundan emin olmak, şartnameye göre elde etmek oldukça zor; (b) akışın uyumlu kaldığından emin olmak için özel read /writeObject () yöntemleri, readResolve /writeReplace () yöntemleri, serializableFields bildirimleri, vb. gibi bir şema denemek için. Asıl @SuppressWarnings’u değiştirmek son çare, umutsuzluk avukatı.
    2012-12-12 00: 59: 01Z
  5. @ SerialVersionUID'nin EJP artışı, sınıfın ilk yazarı açıkça tanıtıldığında ortaya çıktı. Jvm tarafından oluşturulan seri kimliğinin iyi olması gerektiğini söyleyebilirim. bu, serileştirme sırasında gördüğüm en iyi yanıtı .
    2014-12-24 15: 39: 38Z

Josh Bloch'un kitabını eklemek için bu fırsatı yakalayamıyorum. Etkili Java (2. Baskı). Bölüm 11, Java serileştirme için vazgeçilmez bir kaynaktır.

Josh başına, otomatik olarak oluşturulan UID, bir sınıf adına, uygulanan arayüzlere ve tüm genel ve korunan üyelere dayalı olarak oluşturulur. Bunlardan herhangi birini herhangi bir şekilde değiştirmek serialVersionUID'u değiştirecektir. Dolayısıyla, yalnızca sınıfın birden fazla sürümünün serileştirilmeyeceğinden eminseniz (işlemler arasında veya daha sonraki bir zamanda depolama alanından alınan), bunlarla uğraşmanıza gerek kalmaz.

Şimdilik onları görmezden gelirseniz ve daha sonra sınıfı bir şekilde değiştirmeniz, ancak sınıfın eski sürümleriyle uyumluluğu korumanız gerektiğini öğrenirseniz, oluşturmak için JDK aracını serialver kullanabilirsiniz. eski sınıfındaki serialVersionUID ve açıkça yeni sınıfa ayarlandı. (bağlıDeğişikliklerinizde ayrıca serialVersionUID ve writeObject yöntemleri ekleyerek özel serileştirme uygulamanız gerekebilir - bkz. readObject javadoc veya yukarıda belirtilen bölüm 11.)

    
282
2015-10-29 13: 32: 35Z
  1. Biri, bir sınıfın eski sürümleriyle uyumluluk konusunda endişeliyse SerializableVersionUID ile uğraşabilir mi?
    2009-01-01 07: 28: 35Z
  2. Yup, yeni sürüm korumalı herhangi bir genel üyeyi değiştirirse, varsayılan SerializableVersionUID farklı olacaktır ve bir InvalidClassExceptions yükseltir.
    2012-01-13 19: 49: 38Z
  3. sınıf Ad, uygulanan arayüzler, tüm genel ve korunan yöntemler, ALL örnek değişkenleri.
    2013-03-01 04: 38: 29Z
  4. Joshua Bloch'un her Serileştirilebilir sınıf için seri sürümü kullanıcı kimliğini belirtmeye değdiğini bildirmesi önemlidir. Bölüm 11'den alıntı: Hangi serileştirilmiş formu seçerseniz seçin, yazdığınız her seri hale getirilebilir sınıfta açık bir seri sürüm UID'sini bildirin. Bu, olası bir uyumsuzluk kaynağı olarak seri sürüm UID'yi ortadan kaldırır (Öğe 74). Küçük bir performans avantajı da var. Seri sürüm UID'si sağlanmadıysa, çalışma zamanında bir tane oluşturmak için pahalı bir hesaplama gerekir.
    2014-07-08 13: 25: 35Z

Eclipse'e şu serialVersionUID uyarılarını yoksaymasını söyleyebilirsiniz:

  

Pencere > Tercihler > Java > Derleyici > Hatalar /Uyarılar > Potansiyel Programlama Problemleri

Bilmemeniz durumunda, bu bölümde etkinleştirebileceğiniz birçok uyarı var (veya bazıları hata olarak bildirilmiş olsa bile), çoğu çok yararlıdır:

  • Potansiyel Programlama Problemleri: Muhtemel yanlışlıkla boole ataması
  • Potansiyel Programlama Sorunları: Boş işaretçi erişimi
  • Gereksiz kod: Yerel değişken asla okunmaz
  • Gereksiz kod: Yedekli null onay
  • Gereksiz kod: Gereksiz yayın veya 'instanceof'

ve daha fazlası.

    
128
2008-11-13 01: 17: 00Z
  1. olumlu oy verin, ancak yalnızca orijinal poster hiçbir şeyi serileştirmiyor gibi görünüyor. Afiş "Bu şeyi seri hale getiriyorum ve ..." demişse, bunun yerine aşağı oy alırsınız: P
    2008-11-13 01: 28: 31Z
  2. Doğru - Sorgunun sadece uyarılmak istemediğini varsayıyordum
    2008-11-13 02: 52: 08Z
  3. @ Gardner - > kabul! Ancak, sorgulayıcı ayrıca neden uyarılmak istemediğini de bilmek istiyor.
    2009-01-01 07: 29: 35Z
  4. Sorgulayıcı, neden bir UID'nin olması gerektiğiyle ilgili olarak açıkça ilgileniyor. Bu yüzden, sadece uyarmayı görmezden gelmesini söylemek, reddedilmelidir.
    2017-04-18 03: 31: 38Z

Serializable, seri hale getirilmiş verilerin sürümlendirilmesini kolaylaştırır. Serileştirme sırasında değeri verilerle birlikte kaydedilir. Serileştirme işleminde, serileştirilmiş verinin geçerli kodla nasıl eşleştiğini görmek için aynı sürüm denetlenir.

Verilerinizi sürümlendirmek istiyorsanız, normal olarak serialVersionUID/0 ile başlar ve serileştirilmiş verileri değiştiren (geçici olmayan alanlar ekleyerek veya kaldırarak) sınıfınızdaki her yapısal değişiklikle çarpın.

Yerleşik seri hale getirme mekanizması (serialVersionUID), sıfırdan seri hale getirilmeyi reddeder.Verilerin ld sürümleri. Ancak isterseniz, kendi readObject () - eski verileri geri okuyabilen bir işlev. Bu özel kod daha sonra in.defaultReadObject()'u kontrol ederek verilerin hangi versiyonda olduğunu bilmek ve nasıl seri hale getirileceğine karar vermek için kontrol edebilir. Bu sürüm oluşturma tekniği, kodunuzun birkaç sürümünde hayatta kalan serileştirilmiş verileri saklarsanız kullanışlıdır.

Ancak seri hale getirilmiş verileri bu kadar uzun bir süre boyunca saklamak çok yaygın değildir. Seri hale getirme mekanizmasını, örneğin bir önbelleğe geçici olarak veri yazmak veya ağ üzerinden kod tabanının ilgili bölümlerinin aynı sürümüne sahip başka bir programa göndermek için kullanmak çok daha yaygındır.

Bu durumda geriye dönük uyumluluğu korumakla ilgilenmiyorsunuz. Yalnızca iletişimde bulunan kod tabanlarının, ilgili sınıfların aynı sürümlerine sahip olduğundan emin olmakla ilgileniyorsunuz. Böyle bir kontrolü kolaylaştırmak için, serialVersionUID'u aynen önceki gibi tutmalı ve sınıflarınızda değişiklik yaparken güncellemeyi unutmamalısınız.

Alanı güncellemeyi unutursanız, farklı bir yapıya sahip ancak aynı serialVersionUID'lu bir sınıfın iki farklı sürümüyle bitebilirsiniz. Bu olursa, varsayılan mekanizma (serialVersionUID) herhangi bir fark algılamaz ve uyumsuz verileri seri hale getirmeye çalışır. Şimdi kriptik bir çalışma zamanı hatası veya sessiz hatayla (boş alanlar) bitebilir. Bu tür hataları bulmak zor olabilir.

Bu nedenle, bu kullanım tabanına yardımcı olmak için Java platformu, in.defaultReadObject()'u el ile ayarlamama seçeneği sunar. Bunun yerine, derleme zamanında sınıf yapısının bir karması üretilecek ve id olarak kullanılacaktır. Bu mekanizma, aynı kimliğe sahip farklı sınıf yapılarına sahip olmadığınızdan emin olacak ve bu nedenle izlemesi zor olan çalışma zamanı serileştirme hatalarını yukarıda belirtmeyeceksiniz.

Ancak otomatik olarak oluşturulan kimlik stratejisinin arka tarafı vardır. Yani, aynı sınıf için üretilen kimlikleri derleyiciler arasında farklılık gösterebilir (yukarıda Jon Skeet tarafından belirtildiği gibi). Bu nedenle seri hale getirilmiş verileri farklı derleyicilerle derlenmiş kodlar arasında iletirseniz, kimlikleri yine de manuel olarak tutmanız önerilir.

Söz konusu ilk kullanım durumundaki gibi verilerinizle geriye dönük olarak uyumluysanız, muhtemelen kimliği de korumak istersiniz. Bu, okunabilir kimlikleri elde etmek ve ne zaman ve nasıl değiştikleri üzerinde daha fazla kontrol sahibi olmak için.

    
103
2012-10-03 06: 20: 58Z
  1. Geçici olmayan alanların eklenmesi veya kaldırılması, seri serileştirmeyi uyumsuz yapmaz. Bu nedenle, bu tür değişikliklere 'çarpmak' için hiçbir sebep yoktur.
    2014-02-07 01: 05: 33Z
  2. @ EJP: Huh? Veri eklemek, dünyamdaki serileştirme verilerini kesinlikle değiştiriyor.
    2014-02-07 19: 12: 41Z
  3. @ AlexanderTorstling Ne yazdığımı okuyun. 'Serileştirme verilerini değiştirmez' demedim. 'Seri serileştirmeyi uyumsuz kılmıyor' dedim. Aynı şey değil. Nesne Serileştirme Şartnamesi'nin Sürümleme bölümünü okumanız gerekir.
    2014-05-20 21: 27: 51Z
  4. @ EJP: Geçici olmayan bir alan eklemenin zorunlu olarak sınıf seri hale getirmeyi uyumlu hale getirmediğiniz anlamına gelmediğini, ancak değiştiren yapısal bir değişiklik olduğunun farkındayım. veriyi seri hale getirirseniz, yazıyı daha sonra da açıklayacağım geriye dönük uyumlulukla başa çıkmazsanız, bunu yaparken sürümü zorlamak istersiniz. Tam olarak amacın nedir?
    2014-05-21 06: 42: 17Z
  5. Demek istediğim tam olarak söylediğim gibi. Geçici olmayan alanların eklenmesi veya kaldırılması, Serialization sınıfını uyumsuz yapmaz. Bu nedenle, her seferinde serialVersionUID kodunu çarpmanız gerekmez.
    2015-05-04 11: 16: 27Z
  

serialVersionUID nedir ve neden kullanmalıyım?

serialVersionUID iHer sınıf için benzersiz bir tanımlayıcı olan SerialVersionUID, aynı sınıfın Serileştirme sırasında kullanıldığından emin olmak için sınıfın sürümlerini karşılaştırmak için bunu kullanır.

Birini belirtmek daha fazla kontrol sağlar; ancak siz belirtmezseniz JVM bir tane üretiyor. Üretilen değer, farklı derleyiciler arasında farklılık gösterebilir. Dahası, bazen sadece eski serileştirilmiş nesnelerin seri hale getirilmesini yasaklamak için bir sebepten istersiniz [JVM] ve bu durumda serialVersionUID değerini değiştirmelisiniz.

backward incompatibility için javadocs söyle :

  

varsayılan serialVersionUID hesaplaması sınıfa çok duyarlıdır   derleyici uygulamalarına bağlı olarak değişebilen detaylar ve   bu nedenle beklenmedik Serializable s sırasında   seri kaldırma.

Bu nedenle, bize daha fazla kontrol sağladığı için serialVersionUID'yi bildirmelisiniz .

Bu makalenin konuyla ilgili bazı iyi noktaları vardır.

    
67
2018-07-08 07: 03: 56Z
  1. @ Vinothbabu ancak serialVersionUID statik olduğundan statik değişkenler seri hale getirilemez. öyleyse nasıl jvm seriyi kontrol edecek, seri hale getirme nesnesinin sürümünün ne olduğunu bilmeden,
    2014-06-16 11: 06: 45Z
  2. Bu cevapta bahsedilmeyen tek şey, nedenini bilmeden InvalidClassException'u kör bir şekilde dahil ederek istenmeyen sonuçlara neden olabileceğinizdir. Tom Anderson’ın MetroidFan2002’nin cevabı hakkındaki yorumu şöyle: “Kalıcı depolama için serileştirme kullanmıyorsanız, bir değer eklemek yerine @SuppressWarnings’i kullanmanız gerektiğini söyleyebilirim. sizi uyumsuz değişikliklerden korumak için serialVersionUID mekanizması. "
    2014-06-17 16: 30: 51Z
  3. serialVersionUID, değil 'her sınıf için benzersiz bir tanımlayıcıdır'. Tam nitelikli sınıf adı şudur. Bu sürüm göstergesidir.
    2015-06-09 04: 17: 18Z

Orijinal soru, serialVersionUID’un faydalı olacağı why neden bu kadar önemli ’ve“ örnek ”diye sordu. Bir tane buldum.

Serial Version ID sınıfı oluşturduğunuzu, başlattığınızı ve bir nesne akışına yazdığınızı söyleyin. Düzleştirilmiş araba nesnesi bir süre dosya sisteminde oturur. Bu arada, Car sınıfı yeni bir alan eklenerek değiştirilirse. Daha sonra, düzleştirilmiş Car nesnesini okumaya (yani seri hale getirmeye) çalıştığınızda, Car'u elde edersiniz - çünkü tüm serileştirilebilir sınıflara otomatik olarak benzersiz bir tanımlayıcı verilir. Bu istisna, sınıfın tanımlayıcısı düzleştirilmiş nesnenin tanımlayıcısına eşit olmadığında atılır. Gerçekten düşünürseniz, yeni alanın eklenmesi nedeniyle istisna atılır. Açık bir serialVersionUID bildirerek, sürümünüzü kendiniz kontrol ederek bu istisnanın ortaya çıkmasını önleyebilirsiniz. Ayrıca, java.io.InvalidClassException'unuzu açıkça beyan etmek için küçük bir performans avantajı vardır (çünkü hesaplanması gerekmez). Bu nedenle, kendi serialVersionUID'nizi, aşağıda gösterildiği gibi oluşturduğunuz gibi Serileştirilebilir sınıflarınıza eklemek en iyi yöntemdir:

 serialVersionUID     
51
2019-01-14 14: 56: 35Z
  1. Ve biri her UID'ye 1L yerine rastgele uzun bir sayı atamalıdır.
    2017-10-27 01: 34: 29Z
  2. @ abbas 'Biri bu neden yapmalı?' Lütfen ne gibi bir fark yarattığını açıklayın.
    2017-11-25 08: 58: 18Z
  3. Adından da anlaşılacağı gibi, nesneyi serileştirmek için kullanılan sınıfın sürümünü gösterir. Her seferinde aynı numarayı atarsanız, buSeri hale getirmek için doğru sınıf. Bu yüzden sınıfta bir değişiklik yaptığınızda, sürümü de değiştirmek daha iyidir.
    2017-11-27 00: 39: 02Z
  4. @ abbas, bu amaç
    public class Car {
        static final long serialVersionUID = 1L; //assign a long value
    }
    
    'dan itibaren artan doğal sayıları kullanmakla çakışmaz.
    2017-12-14 18: 21: 39Z
  5. @ BillK, seri hale getirme denetiminin classname ve serialVersionUID çiftine bağlı olduğunu düşündüm. Bu yüzden farklı sınıf ve kütüphanelerin farklı numaralandırma programları hiçbir şekilde engel olamaz. Yoksa kod üreten kütüphaneleri mi ima ettiniz?
    2018-01-26 10: 26: 44Z

Nesnelerinizi asla bayt dizisi için seri hale getirmeniz ve onları göndermeniz /kaydetmeniz gerekmiyorsa, endişelenmenize gerek yoktur. Bunu yaparsanız, o zaman serialVersionUID adresinizi göz önünde bulundurmalısınız, çünkü nesnenin seri hale getiricisi onu sınıf yükleyicisinin sahip olduğu nesne sürümüyle eşleştirecektir. Java Dil Özellikleri'nde bunun hakkında daha fazla bilgi edinin.

    
34
2014-07-09 18: 46: 25Z
  1. Nesneleri serileştirmeyecekseniz, neden seri hale getirilebilirler?
    2008-11-13 05: 34: 51Z
  2. @ erickson - ebeveyn sınıfı seri hale getirilebilir, diyelim, ArrayList, ancak kendi nesnenizin (örneğin, değiştirilmiş bir dizi listesi) temel olarak kullanmasını istiyorsunuz, ancak oluşturduğunuz Koleksiyonu asla serileştirmeyeceksiniz.
    2009-03-30 14: 12: 39Z
  3. Java Dil Belirtimi'nde hiçbir yerde bahsedilmedi. Nesne Sürüm Belirleme Belirtiminde bahsedilmiştir.
    2014-02-07 01: 10: 04Z
  4. İşte Java 8'in bağlantısı Nesne Sürüm Belirtimi .
    2014-11-03 04: 12: 45Z

Eğer bu sınıfa seri hale getirme hakkında düşünmediğiniz ve kendinizi 1 ilan etmediğiniz bir uyarı alırsanız, bunun nedeni genellikle Serializable'ı uygulayan bir üst sınıftan miras almanızdır. Çoğu zaman, devralma kullanmak yerine böyle bir nesneye yetki vermek daha iyi olur.

Öyleyse,

yerine  implements Serializable

do

 
public class MyExample extends ArrayList<String> {

    public MyExample() {
        super();
    }
    ...
}

ve ilgili yöntemlerde

public class MyExample {
    private List<String> myList;

    public MyExample() {
         this.myList = new ArrayList<String>();
    }
    ...
}
(veya myList.foo()) yerine this.foo()'u arayın. (Bu, tüm durumlara uymuyor ancak yine de oldukça sık.)

Sık sık JFrame'i ya da böyle bir şeyi genişleten insanları görürüm. (Bu aynı zamanda bir IDE'de otomatik tamamlamaya da yardımcı olur, çünkü JFrame sınıfınızdaki özel olanları aramak istediğinizde gerekmeyen yüzlerce yönteme sahiptir.)

Uyarının (veya serialVersionUID) kaçınılmaz olduğu bir durum, normal olarak anonim bir sınıfta AbstractAction'dan genişlettiğinizde, yalnızca actionPerformed yöntemini eklemenizdir. Bu durumda bir uyarı olmamasını düşünüyorum (normalde sınıfınızın farklı sürümlerinde bu tür anonim sınıfları güvenilir bir şekilde serileştiremez ve seri hale getiremezsiniz), ancak derleyicinin bunu nasıl tanıyabileceğinden emin değilim. p>     

33
2011-02-03 00: 32: 03Z
  1. Miras alma konusundaki kompozisyonun, özellikle ArrayList gibi sınıfları tartışırken daha mantıklı olduğunu düşünüyorum. Bununla birlikte, birçok çerçeve insanların seri hale getirilebilen soyut sınıflardan (Struts 1.2's ActionForm sınıfı veya Saxon'un ExtensionFunctionDefinition gibi) genişletilmesini gerektirir; bu durumda bu çözüm mümkün değildir. Bence haklısınUyarı, bazı durumlarda göz ardı edilirse iyi olurdu (soyut bir seri hale getirilebilir sınıftan yayılıyormuşsunuz gibi)
    2011-12-07 15: 20: 48Z
  2. Elbette, kendisinden miras almak yerine üye olarak bir sınıf eklerseniz, üye sınıfın EVERY yöntemi için istediğiniz bir sarmalayıcı yöntemi yazmanız gerekir. java, perl’in super.foo()’una benzer bir işlevi olmadığı sürece bilmediğim çok sayıda durumda olanaksız kılan bir kullanım.
    2012-08-19 22: 15: 36Z
  3. @ M_M: Sarılmış nesnenize bir çok yöntem devrettiğinizde, elbette yetkilendirme kullanmak uygun olmaz. Ancak, bu durumun bir tasarım hatasının belirtisi olduğunu varsayalım - sınıfınızın kullanıcılarının (örneğin, "MainGui"), sarılmış nesnenin (örneğin, JFrame) birçok yöntemini çağırması gerekmez.
    2012-08-20 08: 09: 56Z
  4. Delegasyondan hoşlanmadığım şey, temsilciye başvuru yapma gereğidir. Her referans daha fazla hafıza demektir. Yanlışsam düzelt. Eğer 100 nesneden bir CustomisedArrayList'e ihtiyacım olursa, bunun önemi olmazdı, ancak birkaç nesneden yüzlerce CustomizdeArrayLists'e ihtiyacım olursa bellek kullanımı önemli ölçüde artar.
    2014-11-29 07: 14: 46Z
  5. Atılabilirlik seri hale getirilebilir ve yalnızca Atılabilirlik atılabilirdir, bu nedenle seri hale getirilemeyen bir istisna tanımlamak mümkün değildir. Delegasyon mümkün değil.
    2017-04-13 02: 59: 08Z

serialSversionUID alanın önemini anlamak için, Serileştirme /Serileştirmenin nasıl çalıştığını anlamak gerekir.

Seri hale getirilebilir bir sınıf nesnesi serileştirildiğinde Java Runtime, seri hale getirilmiş seri numarasını (serialVersionUID olarak adlandırılır) bu serileştirilmiş nesneyle ilişkilendirir. Bu serileştirilmiş nesneyi serileştirdiğinizde, Java Runtime, serileştirilmiş nesnenin serialVersionUID'sini sınıfın serialVersionUID ile eşleştirir. Eğer her ikisi de eşitse, sadece başka bir seriyi silme süreci devam ederse, başka InvalidClassException.

Bu nedenle, Serileştirme /Serileştirme işlemini başarılı kılmak için, serileştirilmiş nesnenin serialVersionUID değerinin, sınıfın serialVersionUID değerine eşit olması gerektiği sonucuna vardık. Programcının programda serialVersionUID değerini açıkça belirtmesi durumunda, aynı değer serileştirme ve serileştirme platformundan bağımsız olarak serileştirilmiş nesne ve sınıfla ilişkilendirilir (örneğin serileştirme için güneş pencereleri kullanılarak platformlar veya pencereler kullanılarak platformda yapılabilir. MS JVM ve Serileştirme, Zing JVM kullanarak farklı platformlarda Linux'ta olabilir).

Ancak serialVersionUID programlayıcı tarafından belirtilmezse, o zaman herhangi bir nesnenin Seriizasyonu \DeSerializasyonu yapılırken, Java çalışma zamanı hesaplamak için kendi algoritmasını kullanır. Bu serialVersionUID hesaplama algoritması bir JRE'den diğerine değişir. Nesnenin serileştirildiği ortamın bir JRE (örn: SUN JVM) kullanıyor olması ve seri kaldırma işleminin gerçekleştiği ortamın Linux Jvm (zing) kullanılması da mümkündür. Bu gibi durumlarda, serileştirilmiş nesneyle ilişkili serialVersionUID, seri kaldırma ortamında hesaplanan sınıfın serialVersionUID değerinden farklı olacaktır. Sırasıyla seri kaldırma başarılı olamayacak. Bu nedenle, bu tür durumlardan /sorunlardan kaçınmak için programcı her zaman Serializable sınıfının serialVersionUID'sini belirtmelidir.

    
22
2014-05-20 21: 34: 52Z
  1. Algoritma değişmiyor, ancak biraz belirtilmiş.
    2014-05-20 21: 35: 10Z

Öncelikle serileştirmeyi açıklamam gerekiyor.
Serileştirme , nesneyi ağ üzerinden göndermek için nesnenin akışa dönüştürülmesini sağlar VEYA Dosyaya kaydet VEYA DB'ye kaydetmektup kullanımı için.

Serileştirme için bazı kurallar var .

  • Bir nesne, yalnızca sınıfı veya üst sınıfı Serileştirilebilir arabirimini uygularsa serileştirilebilir

  • Bir nesne, üst sınıfı olmasa bile serileştirilebilir (Serileştirilebilir arabirimi uygular). Bununla birlikte, seri hale getirilebilir sınıfın hiyerarşisinde, seri hale getirilebilir bir arabirim uygulamamış ilk üst sınıf, bağımsız bir yapıcıya sahip olmamalıdır. Bu ihlal edilirse, readObject () çalışma zamanında bir java.io.InvalidClassException oluşturacaktır

  • Tüm ilkel türler seri hale getirilebilir.

  • Geçici alanlar (geçici değiştiricili) seri hale getirilmedi (yani kaydedilmedi veya geri yüklenmedi). Serileştirilebilir uygulayan bir sınıf, serileştirmeyi desteklemeyen geçici sınıf alanlarını işaretlemelidir (örneğin, bir dosya akışı).

  • Statik alanlar (statik değiştiriciyle) serileştirilmedi.

Nesne Serileştirildiğinde JAVA Runtime, serialVersionID adı verilen seri sürüm numarasını ilişkilendirir.

serialVersionID: \em> 'e ihtiyaç duyduğumuz yerde: Göndericinin ve alıcının serileştirme ile uyumlu olduğunu doğrulamak için seri kaldırma sırasında. InvalidClassCastException ile.
 Serileştirilebilir bir sınıf, statik, final ve uzun olması gereken "serialVersionUID" adlı bir alanı bildirerek kendi serialVersionUID değerini açıkça belirtebilir:

Bunu bir örnekle deneyelim.

 __AUTOLOAD

Serileştirme Nesnesi Oluştur

 
import java.io.Serializable;    
public class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String empname;
private byte empage;

public String getEmpName() {
    return name;
}
public void setEmpName(String empname) {
    this.empname = empname;
}
public byte getEmpAge() {
    return empage;
}
public void setEmpAge(byte empage) {
    this.empage = empage;
}

public String whoIsThis() {
    StringBuffer employee = new StringBuffer();
    employee.append(getEmpName()).append(" is ).append(getEmpAge()).append("
years old  "));
    return employee.toString();
}
}

Nesneyi Deserializ

 
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Writer {
public static void main(String[] args) throws IOException {
    Employee employee = new Employee();
    employee.setEmpName("Jagdish");
    employee.setEmpAge((byte) 30);

    FileOutputStream fout = new 
FileOutputStream("/users/Jagdish.vala/employee.obj");
    ObjectOutputStream oos = new ObjectOutputStream(fout);
    oos.writeObject(employee);
    oos.close();
    System.out.println("Process complete");
}
}

NOT: Şimdi Çalışan sınıfının serialVersionUID değerini değiştirin ve kaydedin:

 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Reader {
public static void main(String[] args) throws ClassNotFoundException, 
IOException {
    Employee employee = new Employee();
    FileInputStream fin = new 
    FileInputStream("/users/Jagdish.vala/employee.obj");
    ObjectInputStream ois = new ObjectInputStream(fin);
    employee = (Employee) ois.readObject();
    ois.close();
    System.out.println(employee.whoIsThis());
 }
}    

Ve Reader sınıfını yürütün. Writer sınıfını çalıştırmak için değil ve istisna alacaksınız.

 
private static final long serialVersionUID = 4L;
    
19
2019-05-03 02: 38: 13Z

Rahatsız etmeyin, varsayılan hesaplama gerçekten iyidir ve vakaların% 99,9999'u için yeterlidir. Sorun yaşarsanız, daha önce de belirtildiği gibi UID'leri ihtiyaç duyulduğu gibi sunabilirsiniz (ki bu pek olası değildir)

    
18
2012-04-29 15: 59: 41Z
  1. Çöp. Sınıfın değişmemiş olması durumunda yeterlidir. '99% 9999'u destekleyecek sıfır kanıtınız var.
    2018-03-22 10: 30: 44Z

Eksik serialVersionUID öğesinin soruna neden olabileceği bir örnek için:

Exception in thread "main" java.io.InvalidClassException: 
com.jagdish.vala.java.serialVersion.Employee; local class incompatible: 
stream classdesc serialVersionUID = 1, local class serialVersionUID = 4
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
at com.krishantha.sample.java.serialVersion.Reader.main(Reader.java:14)
modül kullanan bir Web modülünden oluşan bu Java EE uygulaması üzerinde çalışıyorum. Web modülü EJB modülünü uzaktan çağırır ve EJB'u argüman olarak uygulayan bir POJO'dan geçer.

Bu Serializable sınıfı, EJB kavanozunun içinde ve web modülünün WEB-INF /lib'sinde kendi kavanozunun içinde paketlenmiştir. Onlar aslında aynı sınıftır, ancak EJB modülünü paketlediğimde, bu POJO'nun kavanozunu EJB modülü ile birlikte paketlemek için paketinden çıkardım.

POJO's’a yapılan çağrı aşağıdaki İstisna ile başarısız oldu çünkü EJB’u ilan etmedim:

 serialVersionUID     
18
2013-12-19 18: 15: 18Z

Genel olarak

Caused by: java.io.IOException: Mismatched serialization UIDs : Source
 (Rep.
 IDRMI:com.hordine.pedra.softbudget.domain.Budget:5CF7CE11E6810A36:04A3FEBED5DA4588)
 = 04A3FEBED5DA4588 whereas Target (Rep. ID RMI:com.hordine.pedra.softbudget.domain.Budget:7AF5ED7A7CFDFF31:6227F23FA74A9A52)
 = 6227F23FA74A9A52
'u bir bağlamda kullanırım: Bildiğimde Java VM'nin içeriğinden çıkacağını biliyorum.

Uygulamam için serialVersionUID ve ObjectInputStream kullandığımda ya da kullandığım bir kütüphane /çerçevenin kullanacağını bildiğimde bunu biliyordum. SerialVersionID, farklı sürümlerdeki veya satıcılardan oluşan farklı Java VM'lerinin doğru şekilde çalışmasını sağlar veya VM'in dışında depolanır ve alınırsa, örneğin ObjectOutputStream, oturum verileri uygulama sunucusunun yeniden başlatılması ve yükseltilmesi sırasında bile kalabilir.

Diğer tüm durumlar için kullanıyorum

 HttpSession

çoğu zaman varsayılan

@SuppressWarnings("serial")
yeterlidir. Bu, serialVersionUID, Exception’u içerir.     
15
2014-03-04 16: 17: 48Z
  1. Değiştirilebilecekleri kaplarda HttpServlet'i veya örneğin RMI'de İstisna'yı içermez.
    2014-05-20 21: 36: 16Z

Alan verileri, sınıfta depolanan bazı bilgileri temsil eder. Sınıf HttpServlet arabirimini uygular, böylece tutulma otomatik olarak Serializable alanını bildirmeyi teklif etti. Burada ayarlanan 1 değeriyle başlayalım.

Bu uyarının gelmesini istemiyorsanız, şunu kullanın:

 serialVersionUID     
14
2013-03-13 14: 54: 36Z

SerialVersionUID, nesnenin sürüm kontrolü için kullanılır. Ayrıca seri dosyanızda serialVersionUID değerini belirleyebilirsiniz. SerialVersionUID belirtmemenin sonucu, sınıfta herhangi bir alan eklediğinizde veya değiştirdiğinizde, o zaman zaten seri hale getirilmiş sınıf, yeni sınıf ve eski serileştirilmiş nesne için oluşturulan serialVersionUID farklı olacağından kurtarılamaz. Java serileştirme işlemi, serileştirilmiş nesnenin durumunu kurtarmak için doğru serialVersionUID değerine dayanır ve serialVersionUID uyuşmazlığı durumunda java.io.InvalidClassException öğesini atar

Daha fazla bilgi edinin: http://javarevisited.blogspot.com/2011/04 /üst-10-java-serileştirme-interview.html # ixzz3VQxnpOPZ

    
11
2015-03-25 21: 08: 11Z

CheckStyle, Serializable'ı uygulayan bir sınıftaki serialVersionUID'in iyi bir değere sahip olduğunu, yani seri sürüm kimliği üretecinin üreteceği değerle eşleştiğini doğrularsa iyi olurdu. Çok fazla sayıda seri hale getirilebilen DTO'lu bir projeniz varsa, örneğin, mevcut serialVersionUID'yi silip yeniden oluşturmayı hatırlamak bir acıdır ve şu anda bunu doğrulamanın tek yolu her sınıf için yeniden oluşturmak ve karşılaştırmaktır. eski olan. Bu çok çok acı verici.

    
10
2008-12-03 14: 44: 33Z
  1. serialVersionUID değerini her zaman jeneratörün üreteceği değere ayarlarsanız, gerçekten de buna ihtiyacınız yoktur. Nihayetinde, sınıfın hala uyumlu olması durumunda, değişikliklerinden sonra aynı kalması amaçlanıyor.
    2011-02-20 02: 04: 13Z
  2. Bunun nedeni, farklı derleyicilerin aynı sınıf için aynı değerde gelmesidir. Javadocs'ta da açıklandığı gibi (ayrıca yukarıda cevaplanmıştır), üretilen sürüm kırılgandır ve sınıf uygun şekilde serileştirilebilir olsa bile değişebilir. Bu testi her seferinde aynı derleyicide yaptığınız sürece güvenli olmalıdır. Eğer jdk'i yükseltirseniz ve kod değişmemiş olsa bile yeni bir kural çıkarsa, tanrı size yardım eder.
    2011-08-09 08: 29: 23Z
  3. @SuppressWarnings("serial")
    
    'un üreteceği ile eşleşmesi gerekmez. -1
    2014-02-07 01: 10: 45Z
  4. Genel olarak bu gerekli değildir. @ AndrewBacker'in durumu, aynı .java dosyasında, birbiriyle iletişim kuran .class dosyalarının her iki sürümüyle birlikte iki farklı derleyiciye ihtiyaç duyar - çoğu zaman sadece sınıfı oluşturup dağıtırsınız. Bu durumda, bir SUID'ye sahip olmamak iyi çalışacaktır.
    2018-01-25 21: 06: 35Z
  5. Seri hale getirmeyi depolama /alma amacıyla gerçekten kullanan kişiler genellikle serialver'u 1'e ayarlar. Sınıfın daha yeni bir sürümü uyumlu değilse, ancak yine deEski verileri işleyebilmeyi gerektirir, sürüm numarasını artırır ve eski biçimlerle ilgilenmek için özel kod eklersiniz. Ne zaman serialVersionUID'u 1 basamaktan büyük görsem ağlarım, ya rasgele bir sayı (işe yaramaz) ya da sınıfın görünüşe göre 10'dan fazla farklı sürümle uğraşması gerektiğinden dolayı.
    2018-02-10 11: 11: 51Z

Neden Java'da serialVersionUID sınıfı içinde SerialVersionUID kullanıyorsunuz?

Serializable sırasında, Java çalışma zamanı bir sınıf için sürüm numarası oluşturur, böylece daha sonra seri hale getirilebilir. Bu sürüm numarası Java'da serialization olarak bilinir.

SerialVersionUID, serileştirilmiş verileri sürümlendirmek için kullanılır. Bir sınıfı yalnızca serileştirilmiş örnekle SerialVersionUID eşleşmesi durumunda serileştirebilirsiniz. SerialVersionUID'u sınıfımızda ilan etmediğimizde, Java çalışma zamanı onu bizim için oluşturur, ancak önerilmez. Varsayılan mekanizmayı önlemek için SerialVersionUID'u SerialVersionUID değişken olarak bildirmeniz önerilir.

private static final long işaretleme arabirimini uygulayarak bir sınıfı Serializable olarak bildirdiğinizde, Java çalışma zamanı, java.io.Serializable arabirimini kullanarak işlemi özelleştirmemiş olmanız koşuluyla, varsayılan Serileştirme mekanizmasını kullanarak bu sınıfın örneğini diske aktarır.

ayrıca bkz. Neden kullanılmalı SerialVersionUID, Java'da Serializable sınıfı içinde

Kod: javassist.SerialVersionUID

    
9
2017-03-07 05: 48: 02Z

Eski sınıflarla uyumluluğu koruyarak ilk etapta serialVersionUID ayarlanmamış çok sayıda sınıfı değiştirmek istiyorsanız, IntelliJ Idea, Eclipse gibi araçlar rastgele sayılar ürettiğinden kısa bir süre için düşer ve tek seferde bir sürü dosya. Kolaylıkla serialVersionUID sorununu düzeltmek için aşağıdaki bash betiğini (Windows kullanıcıları için özür dilerim, bir Mac satın almayı veya Linux'a dönüştürmeyi düşünün) geldim:

 Externalizable

bu betiği kaydettiğinizde, add_serialVersionUID.sh dosyasını size ~ /bin olarak söyleyin. Ardından Maven veya Gradle projenizin kök dizininde şöyle çalışın:

 
base_dir=$(pwd)                                                                  
src_dir=$base_dir/src/main/java                                                  
ic_api_cp=$base_dir/target/classes                                               

while read f                                                                     
do                                                                               
    clazz=${f//\//.}                                                             
    clazz=${clazz/%.java/}                                                       
    seruidstr=$(serialver -classpath $ic_api_cp $clazz | cut -d ':' -f 2 | sed -e 's/^\s\+//')
    perl -ni.bak -e "print $_; printf qq{%s\n}, q{    private $seruidstr} if /public class/" $src_dir/$f
done

Bu .lst, serialVersionUID'yi aşağıdaki biçimde eklemek için java dosyalarının listesini içerir:

 
add_serialVersionUID.sh < myJavaToAmend.lst

Bu komut dosyası, kaputun altındaki JDK serialVer aracını kullanır. Bu yüzden $JAVA_HOME /bin'inizin PATH içinde olduğundan emin olun.

    
7
2015-06-27 12: 36: 07Z
  1. Bana bir fikir verir: seri sürümü kullanıcı kimliğini, böyle bir araçla her zaman yeniden oluşturun; hiçbir zaman el ile, serbest bırakmadan önce - bu şekilde Gerçek uyumsuz bir değişiklik nedeniyle seri sürümü kullanıcı kimliğinin değişmesi gereken bir sınıfa geçin. Bunu elle takip etmek çok zor.
    2016-03-17 18: 05: 45Z

Bu soru Etkili Java'da Joshua Bloch tarafından çok iyi belgelenmiştir. Çok iyi bir kitap ve mutlaka okumak gerekir. Aşağıdaki nedenlerden bazılarını ana hatlarıyla açıklayacağım:

Serileştirme çalışma zamanı, serileştirilebilir her sınıf için Seri sürüm adı verilen bir sayı ile gelir. Bu sayı serialVersionUID olarak adlandırılır. Şimdi bu sayının arkasında biraz Matematik var ve sınıfta tanımlanan alanlara /yöntemlere dayanıyor. Aynı sınıf için her zaman aynı sürüm oluşturulur. Serileştirme sırasında bu numara, serileştirilmiş bir nesnenin göndericisinin ve alıcısının, serileştirmeyle uyumlu olan nesne için yüklü sınıflara sahip olduğunu doğrulamak için kullanılır. Alıcı, karşılık gelen gönderenin sınıfından farklı bir seri VersiyonUID'si olan nesne için bir sınıf yüklediyse, seriyi kaldırma işlemi InvalidClassException ile sonuçlanacaktır.

Sınıfın seri hale getirilebilir olması durumunda, bir alan ilan ederek kendi serialVersionUID'nizi de açıkça belirtebilirsinizstatik, final ve uzun olması gereken "serialVersionUID" olarak adlandırıldı. Çoğu IDE Eclipse gibi o uzun dize oluşturmanıza yardımcı olur.

    
6
2015-08-03 19: 41: 31Z

Bir nesne her seri hale getirildiğinde, nesne, nesnenin sınıfı için bir sürüm numarasıyla damgalanır. Bu kimliğe serialVersionUID ve sınıf yapısı hakkındaki bilgilere dayanarak hesaplanır. Bir Çalışan sınıfı oluşturduğunuzu ve # 333 (JVM tarafından atanan) sürüm kimliğine sahip olduğunu varsayalım, Şimdi bu sınıfın nesnesini serileştireceğiniz zaman (Suppose Çalışan nesnesi), JVM UID'yi # 333 olarak atayacaktır.

Bir durumu göz önünde bulundurun - ileride sınıfınızı düzenlemeniz veya değiştirmeniz gerekir ve bu durumda değiştirdiğinizde, JVM ona yeni bir UID atar (Diyelim # 444). Şimdi çalışan nesnesini seri hale getirmeye çalıştığınızda, JVM serileştirilmiş nesnenin (Çalışan nesnesi) sürüm kimliğini (# 333), yani sınıf # 444 (değiştirildiğinden beri) ile karşılaştırır. Karşılaştırmada, JVM her iki versiyonun da UID'yi farklı bulacağını ve bu nedenle Serileştirmenin başarısız olacağını görecektir. Bu nedenle, her sınıf için serialVersionID, programcının kendisi tarafından tanımlanırsa. Sınıf gelecekte geliştirilse bile aynı olacaktır ve dolayısıyla JVM, sınıf değişse bile sınıfın her zaman seri hale getirilmiş nesne ile uyumlu olduğunu görecektir. Daha fazla bilgi için HEAD FIRST JAVA’nın 14. bölümüne bakın.

    
6
2017-05-23 12: 34: 45Z
  1. Bir nesnenin sınıfı her seri hale getirildiğinde,
    com/abc/ic/api/model/domain/item/BizOrderTransDO.java
    com/abc/ic/api/model/domain/item/CardPassFeature.java
    com/abc/ic/api/model/domain/item/CategoryFeature.java
    com/abc/ic/api/model/domain/item/GoodsFeature.java
    com/abc/ic/api/model/domain/item/ItemFeature.java
    com/abc/ic/api/model/domain/item/ItemPicUrls.java
    com/abc/ic/api/model/domain/item/ItemSkuDO.java
    com/abc/ic/api/model/domain/serve/ServeCategoryFeature.java
    com/abc/ic/api/model/domain/serve/ServeFeature.java
    com/abc/ic/api/model/param/depot/DepotItemDTO.java
    com/abc/ic/api/model/param/depot/DepotItemQueryDTO.java
    com/abc/ic/api/model/param/depot/InDepotDTO.java
    com/abc/ic/api/model/param/depot/OutDepotDTO.java
    
    iletilir. Her nesneyle birlikte gönderilmez.
    2017-11-25 09: 00: 06Z

Basit Bir Açıklama:

  1. Verileri seri hale getiriyor musunuz?

    Serileştirme, temel olarak sınıf verilerini bir dosyaya /stream /etc dosyasına yazar. Seri hale getirme, bu verileri bir sınıfa geri okuyor.

  2. Üretime girmeyi düşünüyor musunuz?

    Yalnızca önemsiz /sahte verileri olan bir şeyi test ediyorsanız, endişelenmeyin (doğrudan serileştirmeyi test etmiyorsanız).

  3. Bu ilk sürüm mü?

    Öyleyse, serialVersionUID'u ayarlayın.

  4. Bu ikinci, üçüncü vb. prod versiyonudur mu?

    Şimdi yaklaşık serialVersionUID=1L'dan endişelenmeniz ve derinlemesine bakmanız gerekiyor.

Temel olarak, bir sınıfı güncellediğinizde sürümü doğru şekilde güncellemezseniz, yazmanız /okumanız gereken, eski verileri okumaya çalıştığınızda bir hata alırsınız.

    
2
2019-04-12 13: 44: 29Z

Uzun lafın kısaca anlatılması için, bu alan serileştirilmiş verilerin doğru şekilde seri hale getirilip getirilemeyeceğini kontrol etmek için kullanılır. Seri hale getirme ve seri hale getirme, genellikle programın farklı kopyaları tarafından yapılır; örneğin, sunucu nesneyi dizeye, istemci ise dizeyi nesneye dönüştürür. Bu alan, her ikisinin de bu nesnenin ne olduğu hakkında aynı fikirde çalıştığını söyler. Bu alan şu durumlarda yardımcı olur:

  • programınızın farklı yerlerde birçok kopyası var (1 sunucu ve 100 istemci gibi). Nesnenizi değiştirirseniz, sürüm numaranızı değiştirir ve bu istemcileri güncellemeyi unutursanız, seri kaldırma yeteneğine sahip olmadığını bilir.

  • verilerinizi bir dosyada sakladınız ve daha sonra değiştirilmiş nesneyle programınızın güncellenmiş sürümüyle açmayı deneyin - sürümünüzü doğru tutarsanız bu dosyanın uyumlu olmadığını bilirsiniz

Ne zaman önemlidir?

En belirgin olanı - nesnenize bazı alanlar eklerseniz, eski sürümler bunları kullanamayacaklardır, çünkü bu alanların nesne yapılarında bulunmaması.

Daha az açık - Nesneyi seriden çıkardığınızda, dizede bulunmayan alanlar NULL olarak tutulur. Alanınızı nesnenizden kaldırdıysanız, eski sürümler bu alanı her zaman-NULL olarak tutacaktır; eski sürümler bu alandaki verilere dayanıyorsa, bu durum yanlış davranışa yol açabilir (herhangi bir şey için oluşturduysanız)sadece eğlence için değil :-))

Çok açık - Bazen bir alanın anlamına koyduğunuz fikri değiştirirsiniz. Örneğin, 12 yaşındayken "bisiklet" altında "bisiklet" demek istiyorsun, ama 18 yaşındayken "motosiklet" demek istiyorsun - eğer arkadaşların seni "şehir içinde bisiklete binmeye" davet ederse ve bisikletle çıktığınızda, alanlar arasında aynı anlamı korumanın ne kadar önemli olduğunu anlayacaksınız :-)

    
0
2019-04-15 16: 55: 03Z

Öncelikle sorunuzu yanıtlamak için, sınıfımızda SerialVersionUID bildirmediğimizde, Java çalışma zamanı bizim için üretir, ancak bu işlem alan sayısı, alanların türü, alanların erişim değiştiricisini içeren birçok sınıf meta verisine duyarlıdır , arayüz sınıf tarafından uygulanan vb. Bu nedenle, kendimizi açıklamamız önerilir ve Eclipse sizi aynı konuda uyarıyor.

Serile: Sık sık, durumu (nesnenin değişkenlerindeki veriler) o kadar önemli olan önemli nesnelerle çalışırız ki, nesnenin durumunu diğer makineye göndermesi durumunda güç /sistem arızası (veya) ağ arızası nedeniyle kaybetme riskini alamayız. Bu problemin çözümü, "Kalıcılık" olarak adlandırılır ve bu, verilerin kalıcı olarak (bekletilmesi /kaydedilmesi) anlamına gelir. Seri hale getirme, kalıcılık elde etmenin birçok yolundan biridir (verileri diske /belleğe kaydederek). Nesnenin durumunu kaydederken, nesneyi uygun bir şekilde tekrar okuyabilmek için (seri hale getirme) bir kimlik oluşturmak önemlidir. Bu benzersiz kimlik, ID ise SerialVersionUID'dir.

    
0
2019-04-29 05: 06: 22Z
serialVersionUID
kaynak yerleştirildi İşte