JAXB

JAXB
JAXB JSR 222 ile tanımlı.

Java Architecture for XML Binding (JAXB), which is also known as JSR-222, is a Java technology that provides an easy and convenient way to map Java classes and XML schema for simplified development of Web services.

Bir sınıfa @WebMethod anotasyonu eklenince o sınıf, JAXB context'ine ekleniyor.

JAXB ve Default Constructor
JAXB serialize edilecek sınıfın default constructor'a sahip olması gerekiyor. Mesela Throwable sınıfı default constructor'a sahip olmadığı için XML'e çevrilemez.

JAXB ile XSD Dosyasından Kod Üretme
1. jaxb-xjc.jar dosyası JDK ile gelir (JVM ile değil!). Aşağıdaki komut çalıştırılabilir.

java -jar jaxb-xjc.jar -d src -p jaxb.mypackage -extension xsd\myschema.xsd

-d ile kodun üretileceği dizin belirtilir.
-p ile üretilecek kodun hangi paket içinde olacağı belirtilir.

2. Ya da
jc -p [path] [xsd file] ile de kod üretilebilir.

Kaynak Koddan XSD Üretme
Eclipse ile yaratılan bir JAXB projesinden kaynak koda sağ tıklanıp New -> Other...->JAXB->Schema from JAXB Classes seçeneği kullanılırsa, JAXB anotasyonları kullanılmış kod için XSD üretilir.

Anotasyonlar
Tüm anotasyonlar javax.xml.bind.annotation namespace içinde

XmlRootElement (Sınıf için)
XmlRootElement anatasyonu ile sınıfın XML ve JSON'a otomatik dönüşüm sağlanıyor.

@XmlRootElement(name="pokemon")
public class Pokemon {

    @XmlElement(required=true)
    private String id;
}

name Açıklaması
Sınıfın XML'e dönüştürülürken kullanılacak XML tag'inin ismini belirler. Sınıfın ismi Pokemon olmasına rağmen xml'de küçük farf ile başlar.

<pokemon>
    <id>Charizard</id>
    <!-- Other elements -->
</pokemon>

XmlSeeAlso
Tam ne olduğunu anlamasam da bu anotasyon ile bir sınıf JAXB'ye tanıtılıyor.

XmlElement (Field için)
XmlElement anotasyonu ile bir element'in XML'e nasıl çevirileceği belirtiliyor.

required Açıklaması
Normalde required false değerine sahiptir. Bu durumda xsd dosyası minOccurs=0 olarak  üretilir. Örnek:

<xs:element name="return" type="tns:ucret" minOccurs="0"/>

Eğer required true değerine sahipse xsd dosyası  minOccurs=1 olarak üretilir.

nillable Açıklaması
Buradaki örnekte null olan bir element normalde XML'e çevirilmezken, required=true ve nillable=true kullanılarak çevirilmesi sağlanmış.

Bu durumda xsd dosyası aşağıdaki gibi üretilir.

Buradaki örnekte ise  XmlElement anotasyonuna name bilgisi atanarak üretilen XML'in tagleri değiştiriliyor.

XMLElement anotasyonu JAXB içinde JAXBElement sınıfı ile temsil ediliyor. Eğer göndermek istediğimiz cevap Object gibi generic bir şeyse JAXB her türlü nesneyi XML'e nasıl çeviriceğini bilemeyebilir. Bu gibi durumlarda bazen aşağıdaki gibi bir kod kullanılabilir.

XmlJavaTypeAdapter
Bu anotasyon ile JAXB kurallarına uymayan bir sınıfı (örneğin sınıfın default constructor'ı olmayabilir), uygun hale getirmek mümkün. Örnek.

JAXBContext ile XML Okuma
Önce bir unmarshaller yaratılır.

JAXBContext jaxbContext = JAXBContext.newInstance();
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();

Daha sonra input stream okunur. Aşağıdaki kodda sınıfımın M olduğunu varsayalım.

JAXBElement<M> element = (JAXBElement<M>) unmarshaller.unmarshal(stream);

Daha sonra element.getValue() ile sınıfımız elde edilir.

JAXBContext ile XML Yazma
Bu sınıf ile Customer isimli bir nesneyi XML'e çevirme örneği

JAXBContext jc = JAXBContext.newInstance(Customer.class);
Marshaller marshaller = jc.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
JAXBElement<Customer> jaxbElement = new JAXBElement<Customer>(new QName("customer"), Customer.class, CUSTOMER);
marshaller.marshal(jaxbElement, System.out);

C++ Streamleri

Stream Sınıfları Hiyerarşisi
Yazıya başlamadan önce STL ile gelen stream sınıflarının hiyerarşisini bilmek gerekir.

Stream nesneleri de kendi içinde zengin bir hiyerarşiye sahiptir. Herb Sutter'ın More Exceptional C++ kitabından bu zengin hiyerarşi yüzünden iosfwd header dosyası ile daha basit forward declaration yapmanın önemi anlatılıyor.
Never #include a header when a forward declaration will suffice. Prefer to #include only <iosfwd> when the complete definition of a stream is not needed.

Örneğin aşağıdaki şekli buradan aldım ve stream nesneleri içindeki hiyerarşiyi kolayca görebiliyoruz. Ancak bizim için esas önemli olan her stream ile bir buffer nesnesinin ilişki olması mevzusu.




Bu hiyerarşi bizim C++ kodlarında kullandığımız sınıflar isimlerini içermiyor çünkü birçok sınıf aslında typedef olarak tanımlı. Örnek :

typedef basic_istringstream<char> istringstream;

Stream Sınıflarının Temel Özellikleri

Stream Sınıflarının ve Copy Constructor Metodu Çağırılamaz
Stream sınıflarının copy constructor metodları private tanımlıdır. Stream'leri metodlar referans veya pointer olarak geçebiliriz. Ya da std::shared_ptr ile kullanabiliriz.

Stream Sınıfları ve Assignment Operator Metodu Çağırılamaz
Yukarıdaki açıklamadaki gibi stream metodlarının assignment operator'leri dışarıya açık değildir.

Stream Sınıfları ve Associativity (Birleşme)
Okuma ve yazma işlemlerinde her zaman stream sınıfı ilk önce kullanılır. Eğer

int a, b ;
a << b << cin

şeklinde olsaydı associativity yüzünden derleyici bu ifadeyi

(a << b) << cin

gibi bit kaydırma şeklinde algılardı.

inputstream sınıfları
okuma işlemi bool döner
Örneğin bir akımdan okumak için aşağıdaki gibi yapılır.

while (in >> value) {
}

okuma işleminde hata olursa
okumada hata olursa stream'i temizlemek gerekir. Örnekte int'ten daha büyük bir değer girilirse stream hatalı durumda kalıyor. Tekrar okuma işlemi denense bile çalışmaz. clear () metodu ile failbit bayrağının temizlenmesi gerekir.

int num = 0;
cout << "Enter a number: << endl;
cin >> num;

Temizleme örneği

cin.clear();
cin >> num;

fstream sınıfları
ifstream ve is_open
ifstream ile text dosyanın tüm satırlarını okumak için örnek

ifstream myfile ("filename.txt");
if (myfile.is_open()) {
while ( getline (myfile,line) ) {
    a_file << line << '\n';
}

ofstream
ostream yazısına taşıdım.

sstream sınıfları

stringstream
stringstream'i temizleme için str("") metodu çağırılır. clear() metodu ise strema içindeki flag ve kapasiteyi temizler.

stringstream ss;
ss.str("");
ss.clear();

Tüm Sınıfları İçin StreamBuf

basic_ios ve basic_streambuf (stream buffer nesnesi)

basic_ios sınıfı input ve output stream sınıflarının türediği sınıf olup herkesin kullandığı tüm ortak özellikleri içerir. İçerilen ortak özelliklerin başında ise stream'den okuma yazma işlemleri için soyut bir tampon sınıfı olarak kullanılan basic_streambuf gelir. Dolayısıyla STL ile gelen IOStream kütüphanesinde kullanılan tüm streamlerin içinde bir buffer nesnesi bulunur.

Bu durumu gösteren örnek bir şekli buradan aldım.

Bu buffer nesnesi dolunca nereye boşaltması gerektiğini (sink) veya boşalınca nereden okuması gerektiğini bilir.

Aslında buffer nesnesi ile stream'in birbirinden ayrılması bir strateji tasarım şablonudur.

basic_streambuf yerine sadece streambuf

C++ kodunda yukarıdaki şekilde görülen basic_XXX isimli sınıflar yerine std::streambuf, std::istream gibi sınıflar karşımıza çıkar. Bunun sebebi bir çok sınıfın aslında basic_XXX isimli sınıflar için tanımlanmış typedef'ler olmasıdır. Bu konu ile ilgili bir örnek vermek gerekirse :

std::streambuf aslında std::basic_streambuf sınıfı için tanımlamış bir template ismidir. Yani aşağıdaki gibidir:

typedef basic_streambuf< char > std::streambuf

 Dolayısıyla STL'de kullanılan buffer hiyerarşisi aşağıdaki gibi gösterilirse okuması daha kolay oluyor.

Görüldüğü gibi streambuf olarak kullanılabilecek iki tane nesne bulunmakta. Bunlardan ilki olan filebuf dosyaları okuma/yazma işlevini yerine getirirken, stringbuf ise stringleri okuyup yazma işlevini yerine getirir.

Buffer nesnesi hem input hem de output için kullanılabildiğinden her iki işlev için de metotlar sağlamaktadır.

Aşağıdaki output buffer şeklini buradan aldım ve buffer'ın başlangıç, bitiş ve en son yazılabilecek pozisyonunu veren metotları gösteriyor. Yani buffer'a soldan sağa doğru yazıyoruz gibi düşünülebilir.

Yine aynı şekilde input için kullanılan buffer'ın başlangıç, bitiş ve en son okunabilecek pozisyonunu veren metotları gösteren şekil ise aşağıda. Buffer'ın bu sefer solda sağa doğru okunduğu düşünülebilir.

basic_streambuf'tan türeyen sınıflar
Bu sınıftan türetilen bazı örnek sınıfları görmek için Boost I/O kütüphanesi başlıklı yazıya göz atabilirsiniz.

basic_streambuf'tan kendimizin türetmesi
Buradaki soruda ise streambuf sınıfından bir sınıf türetilerek elimizde sadece file descriptor'ı olan bir stream'e yazma örneği gösterilmiş.overflow ve xsputn sınıfları override edilerek işlem yapılıyor. Kendi türettiğimiz nesneyi stream nesnesine, stream'in constructor'ını kullanarak geçiyoruz.

ACID

ACID Nedir?
Bir relational (ilişkisel) veri tabanı ACID özelliğini sağlamalı. Yani Atomicity (ya hep ya hiç), Consistency (Veri bütünlüğü yani integrity kurallarını ihlal etmeyen), Isolation ve Durability (Transaction bitince veri diske yazılır) özelliklerini sağlamalı.

ACID Kelimesi Nereden Geliyor

Designing Data Intensive Applications kitabındaki açıklama şöyle

It was coined in 1983 by Theo Härder and Andreas Reuter in an effort to establish precise terminology for fault-tolerance mechanisms in databases. However, in practice, one database’s implementation of ACID does not equal another’s implementation. For example, as we shall see, there is a lot of ambiguity around the meaning of isolation. The high-level idea is sound, but the devil is in the details. Today, when a system claims to be “ACID compliant,” it’s unclear what guarantees you can actually expect. ACID has unfortunately become mostly a marketing term.

BASE  Nedir

BASE Properties For Distributed Database Transactions yazısına taşıdım.

Atomicity Nedir (Abortability)

Designing Data Intensive Applications kitabındaki açıklama şöyle. Yani transaction abort edilirse hiç bir değişiklik kaydedilmez.

In general, atomic refers to something that cannot be broken down into smaller parts. The word means similar but subtly different things in different branches of computing. For example, in multi-threaded programming, if one thread executes an atomic operation, that means there is no way that another thread could see the half-finished result of the operation. The system can only be in the state it was before the operation or after the operation, not something in between. 

By contrast, in the context of ACID, atomicity is not about concurrency. It does not describe what happens if several processes try to access the same data at the same time, because that is covered under the letter I, for isolation (see “Isolation” on page 225).

Rather, ACID atomicity describes what happens if a client wants to make several writes, but a fault occurs after some of the writes have been processed—for example, a process crashes, a network connection is interrupted, a disk becomes full, or some integrity constraint is violated. If the writes are grouped together into an atomic transaction, and the transaction cannot be completed (committed) due to a fault, then the transaction is aborted and the database must discard or undo any writes it has made so far in that transaction.

Without atomicity, if an error occurs partway through making multiple changes, it’s difficult to know which changes have taken effect and which haven’t. The application could try again, but that risks making the same change twice, leading to duplicate or incorrect data. Atomicity simplifies this problem: if a transaction was aborted, the application can be sure that it didn’t change anything, so it can safely be retried.

The ability to abort a transaction on error and have all writes from that transaction discarded is the defining feature of ACID atomicity. Perhaps abortability would have been a better term than atomicity, but we will stick with atomicity since that’s the usual word.

ConsistencyNedir

Designing Data Intensive Applications kitabındaki açıklama şöyle.

The idea of ACID consistency is that you have certain statements about your data (invariants) that must always be true—for example, in an accounting system, credits and debits across all accounts must always be balanced. If a transaction starts with a database that is valid according to these invariants, and any writes during the transaction preserve the validity, then you can be sure that the invariants are always satisfied.

However, this idea of consistency depends on the application’s notion of invariants, and it’s the application’s responsibility to define its transactions correctly so that they preserve consistency. This is not something that the database can guarantee: if you write bad data that violates your invariants, the database can’t stop you. (Some specific kinds of invariants can be checked by the database, for example using foreign key constraints or uniqueness constraints. However, in general, the application defines what data is valid or invalid—the database only stores it.)

Atomicity, isolation, and durability are properties of the database, whereas consistency (in the ACID sense) is a property of the application. The application may rely on the database’s atomicity and isolation properties in order to achieve consistency, but it’s not up to the database alone. Thus, the letter C doesn’t really belong in ACID.

Isolation Nedir

ACID - Isolation yazısına taşıdım

Durability Nedir

Designing Data Intensive Applications kitabındaki açıklama şöyle.

The purpose of a database system is to provide a safe place where data can be stored without fear of losing it. Durability is the promise that once a transaction has committed successfully, any data it has written will not be forgotten, even if there is a hardware fault or the database crashes.

In a single-node database, durability typically means that the data has been written to nonvolatile storage such as a hard drive or SSD. It usually also involves a write-ahead log or similar (see “Making B-trees reliable” on page 82), which allows recovery in the event that the data structures on disk are corrupted. In a replicated database, durability may mean that the data has been successfully copied to some number of nodes. In order to provide a durability guarantee, a database must wait until these writes or replications are complete before reporting a transaction as successfully committed.

As discussed in “Reliability” on page 6, perfect durability does not exist: if all your hard disks and all your backups are destroyed at the same time, there’s obviously nothing your database can do to save you.

Coalesce

Giriş
Coalesce kelimesi co - alescere (Latince) kelimelerinden oluşuyor. Ben birleştirme diye çevirdim.

Coalesce (null birleştirme) bazı programlama dillerinde bulunan bir metod. Verilen bir çok parametreyi tek bir sonuç haline getiriyor. Yani birleştiriyor. Bunu yaparken null olmayan ilk değeri döndürüyor.

SQL
Örnek:
COALESCE(a,b,c)

C#
Null Coalescing Operator yazısına taşıdım.

Java
Java'da bu metod yok. Ancak yazması da çok kolay. Örnek:

public static <T> T coalesce(T a, T b) {
    return a != null ? a : b;
}
public static <T> T coalesce(T a, T b, T c) {
    return a != null ? a : coalesce(b,c);
}
public static <T> T coalesce(T a, T b, T c, T d) {
    return a != null ? a : coalesce(b,c,d);
}
public static <T> T coalesce(T a, T b, T c, T d, T e) {
    return a != null ? a : coalesce(b,c,d,e);
}

Propagate
Null Propagating Operator C# 6 ile geliyor/gelecek.

?. şeklinde kullanılıyor. Yani eskiden nokta ile kullandığımız yere ? işaretini de ekliyoruz.

Coalesce ile aynı şey değil ancak ilgili olduğu için aynı yazıya taşıdım. Bir nesnenin property'si ile çalışırken sürekli null kontrolü yapmamak için kullanılıyor.

Nested Property İçin Kullanımı
Önce nesnenin iç içe propertylerine erişimi nasıl yaptığımıza bakalım.
Eskiden böyle yazardır

StringBuilder stringBuilder = new StringBuilder();
//Wanted object can be even deeper
if (root != null &&
    root.InnerObject1 != null &&
    root.InnerObject1.InnerObject2 != null &&
    root.InnerObject1.InnerObject2.InnerObject3 != null &&
    root.InnerObject1.InnerObject2.InnerObject3.value != null)
{
    stringBuilder.Append(root.InnerObject1.InnerObject2.InnerObject3.value)
}

Şimdi sadece böyle yazıyoruz.

var value = root?.InnerObject2?.InnerObject2?.InnerObject3?.value;
if(value != null)
    stringBuilder.Append(value);

Nested Property'nin Nullable İle Kullanımı
Yukarıdaki koddan farklı değil. İstersek değer yine bir nullable alana atayabiliriz.

Type? v = x?.y?.z; 

Nested Property'nin bir metodunu Çağırmak
Bu da mümkün.

this.AnalyzerLoadFailed?.Invoke(...);

Bu kod aslında şuna denk gelir.

if( this.AnalyzerLoadFailed != null)
    this.AnalyzerLoadFailed.Invoke(...);