Annotation Part#3 (Final)

บทความสุดท้ายนี้ เราจะกล่าวถึง 3 ตัวที่เหลือ ก็คือ Default Value, Single Value Annotation, และ Marker Annotation ครับ

Default Value
บางครั้ง element ใน annotation เราสามารถกำหนดค่าเริ่มต้นให้กับ element ได้โดยใช้คำสงวนว่า default แล้วตามด้วยค่าที่ต้องการให้เป็นค่าเริ่มต้นของ element ดังตัวอย่างด้านล่าง

 () default "Default" ; 

เราลองไปดูในตัวอย่างใน file CTest.java โดยในนี้จะมีการประกาศ element ให้มีค่าเริ่มต้นไว้ทั้งหมด

@Retention(RetentionPolicy.RUNTIME)
@interface Author  {
String name() default "John Rambo" ;
String email() default "john@rambo.com";
}

จากนั้นลอง run ดูตามใน code ตัวอย่าง


Single Value Annotation
ในบางครั้งที่ annotation ของเรามี element แค่เพียง element เดียว ทำให้เราก็ไม่อยากจะมากำกับชื่อของ element ดัง เช่น @Author สังเกตได้ว่ามีเพียงแค่ element เดียวก็จริงแต่เวลาที่เราเรียกใช้นั้นเรายังต้องระบุชื่อในการกำหนด element

@Author( name = "John Rambo" )

แต่เราจะเรียกแบบไม่ระบุชื่อแบบตัวอย่างด้านล่างนี้ไม่ได้

@Author("John Rambo")

การที่เรามี element แค่เพียง element เดียว และเราต้องการที่จะไม่ต้องใส่ชื่อของ element ในตอนใช้ annotation เราต้องประกาศ element ที่มีชื่อว่า value

String value();

จากนั้นเราลองไปดูในตัวอย่างกัน

@Retention(RetentionPolicy.RUNTIME)
@interface Author {
String value();
}

จากนั้นเราลองเรียกใช้ดู

@Author("John Rambo")
class D { }

class DTest {
public static void main(String args[]) {
Author a = D.class.getAnnotation(Author.class);
System.out.println(a.value());
}
}

สังเกตเวลาเราเอาค่าออกมานั้นก็ยังใช้วิธีเหมือนเดิม

NOTE
ลองดูว่าเราสามารถประกาศ element value ปนกับ element อื่นได้ไหม ถ้าได้เราจะยังสามารถประกาศ Annotation แบบที่ไม่ต้องระบุชื่อ element ได้อีกไหม (คำตอบคือได้**แต่ต้องระบุค่า element อื่นให้มีค่าเป็น default ด้วย**)

Marker Annotation
เป็น annotation ที่ไม่มี element อะไรทั้งสิ้น โดยที่มีไว้เหมือนเป็นจุดมุ่งหมายเพื่อทำการ mark ยกตัวอย่างเช่น

// ETest.java   Marker
@Retention(RetentionPolicy.RUNTIME)
@interface John{ }

@Retention(RetentionPolicy.RUNTIME)
@interface Jack{ }

@John
class A {
@Jack
public void f() { }
}

ในตัวอย่างนี้มี @John และ @Jack ซึ่งเป็น annotation ที่ไว้ใช้ประกาศว่าใครเป็นผู้สร้าง source code อะไรซึ่งคล้ายกับ @Author เพียงแต่การต้องระบุ element name ลงไปเพื่อเป็นการแยกว่าเป็นใคร แต่ Mark Annotation นั้นใช้ annotation เป็นตัวแยกเลย ซึ่งวิธีการใช้ก็จะแตกต่างกันนิดหน่อย

class ETest {
public static void main(String args[]) throws Exception {
System.out.println(A.class.isAnnotationPresent(John.class));
System.out.println(A.class.isAnnotationPresent(Jack.class));

Method m = A.class.getMethod("f");
System.out.println(m.isAnnotationPresent(John.class));
System.out.println(m.isAnnotationPresent(Jack.class));
}
}

ของเดิมเราจะเอาค่าของ element ใน annotation มาใช้แต่ในของ Mark Annotation นั้นเราเอา annotation มาใช้เปรียบเทียบดังใน code ตัวอย่าง


Reference from : dr. Werasak Suengtaworn

Compose by : @plaumkamon

ข้อเขียนนี้ช่วยฉัน:

Annotation Part#2

Class Annotation

เราจะมาดูตัวอย่างการใช้กันใน class A

// A.java Class Annotation

import mytag.Author;
import mytag.Version;

@Author( name = "John Rambo" )
@Version( major = 1, minor = 1 )

public class A { }

ซึ่งการประกาศ annotation นั้นจะไปประกาศหน้า class เพื่อบอกว่าใครคือผู้สร้าง class นี้และเป็น version อะไร สังเกตว่า annotation จะประกาศกี่อันก็ได้ จากนั้นเราจะมาดูวิธีเรียกใช้ annotation กันว่า ว่ามีวิธีเรียกยังไงใน class ATest

โดยก่อนที่เราจะเรียกใช้เราลอง compile file A.java ดูก่อน โดยเปิด cmd ขึ้นมาแล้วไปยัง directory anno ดังตัวอย่างรูปด้านล่าง

ให้ compile class ใน package mytag ทั้งหมดก่อนโดยใช้คำสั่งดังนี้

javac mytag\*.java

จากนั้นลอง compile A.java โดยคำสั่ง

javac A.java

จากนั้นเราลองดูขนาด file A.class กันว่ามีขนาดเท่าไรโดยใช้คำสั่ง

dir A.class

จะพบว่ามันมีขนาดมาถึง 311 byte ถือว่าเยอะมากสำหรับ class ธรรมดาโดยปกติจะประมาณ 100 กว่า byte ทดสอบได้โดย comment annotation ใน A.java ออกแล้วลอง compile ใหม่ดูจะพบว่าเนื้อที่ของ A.class จะเหลือเพียง 176 byte เท่านั้น ที่เป็นเช่นนี้เพราะมันจะเก็บ element ของ annotation เหล่านี้ไว้ใน A.class

ต่อมาลองเรียกใช้ annotation กันซึ่ง class แรกที่เราจะลองนั้นคือ ATest.java

// ATest.java
import mytag.Author;
import mytag.Version;

class ATest {
public static void main(String args[]) {
Author a = A.class.getAnnotation(Author.class);
System.out.println("Author: " + a.name());
Version v = A.class.getAnnotation(Version.class);
System.out.println("Version: " + v.major() + "." + v.minor());
}
}

การจะเอา annotation ที่ติดอยู่ใน class ออกมา เราจะเรียกใช้ property class ซึ่งติดอยู่ใน class ทุก class ที่เราสร้างขึ้นมา โดย property class จะไปอ้างถึง file A.class ที่เราได้มาจากการ compile A.java จากนั้นเราใช้ method getAnnotation(Author.class) โดยตอน get นั้นต้องใส่ property class ของ annotation ที่เราต้องการจะอ่านด้วยจากนั้นเมื่อได้ annotation แล้วเราจึง get ค่าต่างๆออกมากตามที่เรากำหนดไว้ใน element ( การที่เราสามารถดึงค่า annotation ที่อยู่ใน class ออกมาได้นั้นเป็นเพราะ เราใช้ Refection API เข้ามาช่วย ในตัวอย่างนี้เป็นเพียงแค่ เศษเสี้ยวของความสามารถของ Reflection API เท่านั้น สามารถศึกษาต่อได้ ที่นี่ )

System.out.println("Author: " + a.name());
System.out.println("Version: " + v.major() + "." + v.minor());

Class Member Annotation

จากที่เราลองประกาศ annotation บน class แล้ว เราลองประกาศ annotation บน attribute และ method ดูบ้าง ลองไปดูใน code BTest.java ดู ในนั้นจะมี class B อยู่ โดย class B ใน BTest.java จะมีการประกาศ annotation บน attribute และ method ดัง code ด้านล่าง เพื่อเป็นตัวบอกว่า attribute หรือ method เหล่านี้ใครเป็นผู้สร้าง

// part of BTest.java
class B {
@Author( name = "John Rambo" )
public int x;
@Author( name = "Jack Ripper" )
public static void f() { }
}

จากนั้นเราลองดึงเอา annotation ออกมาใช้ โดยวิธีการดึงและการเรียกออกมา จะมีวิธีการเรียกที่แตกต่างกับวิธีของ Class Annotation ดัง code ด้านล่าง

// part of BTest.java
public static void main(String args[])
throws NoSuchMethodException, NoSuchFieldException {
Field f = B.class.getField("x");
Author fanno = f.getAnnotation(Author.class);
System.out.println(fanno.name());

Method m = B.class.getMethod("f");
Author manno = m.getAnnotation(Author.class);
System.out.println(manno.name());
}

ถ้าลองสังเกตจากตัวอย่างที่แล้ว การดึง annotation ในประเภท Class Annotation เราสามารถดึงออกมาเป็น Object ของ annotation นั้นได้โดยตรงๆ แต่การดึง annotation ในประเภท Class Member Annotation นั้นไม่ใช่ การจะดึงออกมาต้องดึงออกมาเป็น object ของ java.lang.reflect.Field ถ้าหากเราจะดึง annotation ของ attribute แต่ถ้าเป็นการดึง annotation ของ method เราต้องดึงออกมาเป็น object ของ java.lang.reflect.Method

Field f = B.class.getField("x");
Method m = B.class.getMethod("f");

โดยการเรียก object ของ java.lang.reflect.Field และ java.lang.reflect.Method นั้น เราจะเรียกผ่าน method getField() และ getMethod() ตามลำดับโดยต้องระบุชื่อของ attribute หรือ method ที่ต้องการเรียก annotation ของ attribute หรือ method นั้นๆ จากนั้นเราจึงเอา object ของ java.lang.reflect.Field และ java.lang.reflect.Method นั้นมาดึงเอา annotation ออกมาอีกที

Author fanno = f.getAnnotation(Author.class);
Author manno = m.getAnnotation(Author.class);

ซึ่งจากทั้งสองตัวอย่างคงจะเข้าใจ annotation มากขึ้น ซึ่งเราจะมาเล่นของลูกเล่นใน annotation กันต่อ

คราวหน้า เราจะมาต่อกันด้วย Default Value นะครับ

Reference from : dr. Werasak Suengtaworn

Compose by : @plaumkamon

ข้อเขียนนี้ช่วยฉัน:

Annotation Part#1

จาก EJB 2.1 ถ้าหากใครลองเขียนหรือใช้งานดูจะพบว่ามันยุ่งยากมาก ขนาดแค่ Bean เดียวกว่าจะ implement ออกมาก็เหนื่อยแล้ว เพราะมีการ config มากทำให้การใช้งาน EJB 2.1 ค่อนข้างจุกจิก วุ่นวายและยุ่งยาก ที่เป็นเช่นนี้เพราะ การออกแบบ ejb2 ของ sun นั้นได้แบ่ง programmer ออกตาม ตามหน้าที่โดยจะแบ่งหน้าที่เป็น 3 ฝ่ายโดยคร่าวๆดังนี้

• Programmer: programmer เป็นผู้เขียน beans ทั้งหลายโดยที่แต่ละ beans นั้นจะทำหน้าที่เพียงแค่อย่างใดอย่างหนึ่งเท่านั้น

• Assembler: assembler นั้นจะเป็นผู้ที่รู้เกี่ยวกับ business logic ดีมากๆ เป็นผู้นำ beans ต่างๆเหล่านี้มาร้อยเรียงกันใหม่จนหลายเป็น services

• Deployer: เป็นผู้ที่นำ beans ต่างๆเอาเข้าระบบ รวมทั้งเป็นผู้ที่คอย config xml ต่างๆทั้งหมด

จะเห็นว่าถ้าหากในองค์กรเรามี role ต่างๆเหล่านี้ ภาระการ config จะตกอยู่กับ deployer ส่วน programmer นั้นไม่จำเป็นต้อง config เองและไม่ต้องรู้ business เพราะ assembler จะเป็นผู้นำไปร้อยเรียงเอง ซึ่งถ้าถามว่าในองค์กรขนาดเล็กจะมีคนที่ทำหน้าที่อย่างที่ sun กำหนดไหม คำตอบคือไม่ ยกตัวอย่างเช่น software house ในไทย programmer คนเดียวทำงานตั้งแต่ programmer ยัน SA หรือจนไปถึง PM, Consultant ออกไปหาลูกค้าด้วยยังมีเลย ดังนั้นการที่เราจะใช้ ejb2.1 นั้นต้องยุ่งยากมาก ทำให้การแบ่งหน้าที่ตามที่ sun เป็นผู้ออกแบบไว้เป็นไปไม่ได้

และเนื่องจากว่า beans ที่ programmer เขียนขึ้นมานั้นจะไม่สามารถนำมาทดสอบได้เพราะว่ายังไม่มีการ config ไม่มีการนำไป deploy ดังนั้นถ้าหาก deployer ไม่ deploy ให้ก็จะไม่มีทาง check ได้ว่า beans ที่ programmer เขียนนั้นถูกไหมดังนั้นมันเป็นเรื่องที่ยุ่งยากมากเพราะต้องคอยประสานกับอีกฝ่ายทำให้ระยะเวลาการทำงานมากขึ้น แต่การที่ programmer จะมา config เองนั้น เป็นเรื่องที่ปวดตับ (เน้นว่าปวดตับไม่ใช่ปวดหัว) มากกับ programmer ดังนั้นจึงมีคนเสนอมาว่าการ config ต่างๆนั้น แทบจะไม่ได้มีการเปลี่ยนแปลงอะไรเลย

ทำไมเราต้องมาแยกกันด้วยทำไมเราไม่เอา config เหล่านั้นลงใน code เลย ซึ่งแนวคิดนี้ได้ถูกนำไปพัฒนาจนกลายเป็น meta data ที่ใส่ลงไปใน program แต่จะไม่ถูกทำงานตอนเวลา compile time แต่จะถูกอ่านค่าต่างๆเหล่านี้เวลา runtime เพื่ออ่านค่า config เหล่านี้ออกมา ซึ่ง metadata ตัวนี้เราเรียกว่า XDocLet โดยเราเขียนค่า config เหล่านี้ลงใน code จากนั้น XDoclet จะสร้าง (generate) xml config ต่างๆให้หรือว่าแม้กระทั้ง java source code โดยพื้นฐานนี้มาจาก JavaDoc ซึ่งเราสั่งเกตไหมว่าเราสามารถ generate JavaDoc มาจาก source code ได้เลย เพียงแต่เราต้องใส่ comment เข้าไปเพื่อไว้เป็นรายละเอียดของ JavaDoc เท่านั้น เช่น

/**
* Returns an Image object that can then be painted on the screen.
* The url argument must specify an absolute {@link URL}. The name
* argument is a specifier that is relative to the url argument.
* <>
* This method always returns immediately, whether or not the
* image exists. When this applet attempts to draw the image on
* the screen, the data will be loaded. The graphics primitives
* that draw the image will incrementally paint on the screen.
*
* @param url an absolute URL giving the base location of the image
* @param name the location of the image, relative to the url argument
* @return the image at the specified URL
* @see Image
*/
public Image getImage(URL url, String name) {
try {
return getImage(new URL(url, name));
} catch (MalformedURLException e) {
return null;
}
}

ใช้ @ ไปเพื่อให้ JavaDoc Tool อ่านไปเพื่อนำเอาไปใช้ทำ API Doc แต่สังเกตว่าต้องมีการใส่ comment ด้วยเพราะว่าเครื่องหมาย @ นั้นยังไม่รองรับใน J2SE 1.4 ซึ่งอาจจะยังงงๆอยู่ลองดูดังรูปด้านล่าง
 

ต่อมา sun ได้นำแนวคิดนี้ไปผนวกกับ java ใน version 5.0 ซึ่งทำให้ EJB 3.0 พลอยได้รับอานิสงส์นี้ไปด้วย จากที่ต้อง config xml ที่แสนปวดตับกลายมาเป็นประกาศการ config เหล่านั้นลงใน java code แทน ซึ่ง java จะเรียก meta data นี้ว่า annotation
Annotation นั้นคือ meta data ที่แทรกลงไปใน code แต่จะไม่ถูก compile เหมือนปกติแต่จะเป็นตัวบ่งบอก ตัว java runtime (JRE) ว่า ขณะ ณ ตอนนั้นให้ทำอะไรซึ่งจะแบ่ง annotation เป็น 3 ประเภทคือ

• Information for the compiler : เป็น annotation ที่บอก compile เพื่อไว้ใช้สำหรับ detect error หรือ suppress warnings ยกตัวอย่างเช่น
  
  
  
  • @Override เพื่อบ่งบอกว่า method นี้ถูก override มาจาก class แม่
  • @Deprecated เพื่อบ่งบอกว่า method หรือ class
  นี้นั้นควรที่จะหลีกเลี่ยงหรือว่าไม่ควรจะใช้เพราะว่าเป็นอันตรายหรือว่ามี method ที่ดีกว่านี้ให้เลือกใช้
  
  
• Compiler-time and deployment-time processing : เป็น annotation ที่ให้ Software tools อ่าน annotation เหล่านั้นเพื่อนำไปสร้าง file ต่างๆ เช่น xml, javadoc และอื่นๆ

• Runtime processing : เป็น annotation ที่บ่งบอกให้ JRE นั้นทำงานตอน runtime

ซึ่งเราก็จะมาดูวิธีการสร้างและวิธีการเรียกใช้กันโดยที่เราจะเน้นที่ annotation แบบ Runtime processing เพียงเท่านั้นเพราะว่าใน EJB3.0 นั้นไม่มีการ config xml และ annotation ใน EJB3.0 จะทำงานต่างกันกับ XDoclet เพราะว่าไม่ใช่ annotation แบบ Compiler-time and deployment-time processing แต่เป็นแบบ Runtime processing เรามาลองดูกันเลยดีกว่า แต่ไม่ได้หมายความว่าเราจะไม่สามารถสร้าง annotation แบบ Information for the compiler ได้ เราทำได้โดยไปกำหนด policy ตอนที่เราสร้าง annotation ซึ่งลองไปดู code กันเลยดีกว่า ซึ่งเราจะสร้าง annotation ไว้ทดลองสองตัวคือ

// mytag.Author.java
package mytag;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface Author {
String name();
}

การสร้าง annotation ใช้ @interface ในการประกาศซึ่งในที่นี้เราตั้งชื่อว่า Author จากนั้นเรากำหนด annotation ของเราให้เป็นแบบ Runtime processing โดยกำหนด policy ดังนี้

@Retention(RetentionPolicy.RUNTIME)

ซึ่งการกำหนด policy นั้นมีด้วยกัน 3 อย่างคือ

• RetentionPolicy.CLASS: Information for the compiler
• RetentionPolicy.RUNTIME: Runtime processing
• RetentionPolicy.SOURCE: Compiler-time and deployment-time processing

จากนั้นก็จะมีการ set element ที่ชื่อว่า name ด้วยซึ่งตรงนี้จะมีกี่อันก็ได้และต้องตั้งตาม syntax นี้

<type> <nameofelement>( );

สังเกตุว่าเหมือนการประกาศ abstract method ธรรมดาเพียงแต่ไม่มีการรับ parameter ใดๆทั้งสิ้นใน method นั้น ใน annotation จะมีแต่การประกาศ element เท่านั้นไม่มีการประกาศ attribute หรือ method ใดๆทั้งสิ้น จากนั้นเราก็มาดู annotation อีกตัวคือ

// mytag.Version.java
package mytag;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface Version {
  int major();
  int minor();
}

annotation Version จะมี element ด้วยกันสองตัว annotation Author เราเอามาใช้ในการเก็บชื่อว่าใครเป็นคนเขียน class, method หรือ attribute นี้ขึ้นมา ส่วน annotation Version จะบ่งบอกว่า class, method หรือ attribute นั้นผ่านการปรับปรุงมาถึง version ไหนแล้ว การใช้ annotation มีลักษณะเป็นแบบ location sensitive คือ เมื่อเราเอา annotation ไปแปะไว้ตรงหน้าอะไร ก็จะเป็นการประกาศ annotation ของ สิ่ง นั้น เช่น เอาไว้หน้า class มันก็จะเป็น annotation ของ class นั้นๆ เป็นต้น ซึ่งการประกาศ annotation นั้นสามารถประกาศได้ 2 ชนิดคือ

• Class Annotation
• Class Member Annotation

ตอนหน้าเราจะมาดูกันว่า Class Annotation  และ Class Member Annotation เป็นอย่างไร

Reference from : dr. Werasak Suengtaworn

Compose by : @plaumkamon

ข้อเขียนนี้ช่วยฉัน:

Oracle Enterprise Pack for Eclipse (OEPE)

Oracle Enterprise Pack for Eclipse (OEPE)

มันคือ plug-in ของ eclipse ที่ออกมาโดย oracle โดยที่ plug-in ตัวนี้จะรองรับ product ต่างๆที่เกี่ยวข้องกับ SOA และ product ของ oracle ทั้งหมดไม่ว่าจะเป็น Oracle WebLogic Server, Oracle Database และ Kodo JDO นอกจากนั้นยังมี tool ที่ support Spring, JSF Facelets และ Struts อีกด้วย แต่ที่น่าแปลกไม่มี TopLink, ADF หรือ BC4J ของ oracle เลย (หรือว่ามันตายไปแล้วนะ)

SOA

OEPE จะช่วยในการพัฒนา SOA ให้ง่ายขึ้นโดยใช้ feature FastSwap ของ Weblogic เข้ามาช่วยในการ development

FastSwap ถ้าหากต้องการคำนิยามง่ายๆก็เปรียบได้กับ java rebel ที่ตอนนี้กำลังเป็นที่นิยมกัน โดย FastSwap และ java rebel นั้นจะมีการทำงานที่คล้ายกัน โดยปกตินั้นเวลาที่เราต้องทำงานที่เกี่ยวกับ web หรือ web services สิ่งที่หนีไม่พ้นนั้นก็คือวัฏจักรวงจรเดิมๆในการ develop คือ Edit -> Build -> Deploy -> Test เมื่อ test เสร็จแล้วต้องการจะแก้ต้องกลับไป edit เมื่อ edit เสร็จจะ test ต้องเจอกับ build ก่อน (pack เป็น jar, war, ear) จากนั้นก็นำไป deploy แล้วจึงสามารถ test ได้ ซึ่งการ deploy ใหม่นั้นบางครั้งต้องมี undeploy อีก ซึ่งหากเราไปแก้ไข วัฏจักรวงจรเดิมๆ เหล่านี้โดยตัดบางอย่างออกไปได้ก้จะทำให้พัฒนาได้เร็วขึ้น (เพราะว่าผมก็เคยเจอเหตุการณ์นี้ในตอนทำงานระหว่างรอ EJB 2.0 กว่าจะ build กว่าจะ deploy กว่า restart application server หมดเวลากันไป 10-20 นาที) โดย FastSwap และ java rebel นั้นจะเอาขั้นตอนการ deploy ออกไป ดูให้เห็นภาพไปดู vdo นี้กัน

ข้อเปรียบระหว่าง FastSwap กับ java rebel

FastSwap พื้นฐานของมันมากจาก feature ใหม่ของ Java SE 5’s dynamic class redefinition จะใช้ Instrumentation interface ในการ redifining classes ทำให้ถ้าต้องการใช้ feature นี้ ต้องเป็น project ที่ support JDK 5.0 ขึ้นไป (ref ของเรื่อง dynamic class redefinition หายากมากและเป็น feature ไม่เคยรู้มาก่อนจริง) และมีข้อจำกัดมากมาย Limited reflection support (no new/changed/deleted methods/class annotation/type annotations) -> no framework support (details at the end) และผูกติดกับ Weblogic

java rebel ไม่ได้ใช้ feature ของ Java SE 5’s dynamic class redefinition แต่สร้างขึ้นมาเอง ดังนั้นจึง support JDK ตั้งแต่ version 1.4 ขึ้นไปและมีข้อจำกัดไม่มากเหมือน FastSwap ด้วย และสามารถนำไปใช้ได้เกือบทุก platform ของ java ไม่ได้ผูกติดกับ application server

Oracle Weblogic

OEPE นั้นช่วยให้การใช้งานหรือการ configuration Weblogic ได้ง่ายขึ้น เพราะว่าในตอนนี้ eclipse ยังไม่ support Oracle Weblogic ดังนั้นใครที่ทำงานเกี่ยวกับ Oracle Weblogic โดยใช้ eclipse หละก็ plug-in ตัวนี้ก็เหมาะอย่างมาก

Oracle Database

ต่อกับ oracle database และตัวอื่นๆใน Data source explorer รู้สึกครบเครื่องมาก มีลูกเล่นมากขึ้น มากกว่า Data source explorer ธรรมดา และสามารถ view diagram ของแต่ละ table ได้ด้วย

Kodo JDO

JDO ถ้าจะมองให้ง่ายๆมันก็คือ EJB 3.0 ตัวหนึ่งที่มีบางสิ่งที่ต่อเติมขึ้นมาทำให้ EJB 3.0 มีประสิทธิภาพและใช้งานง่ายขึ้น ซึ่งถ้าใครใช้งาน EJB 3.0 อยู่แล้วจะมาเปลี่ยนเป็นใช้ JDO นั้นแทบไม่ต้องปรับเปลี่ยนอะไรเลยเพียงแต่เรียนเพิ่มเติมในส่วนที่เพิ่มเข้ามาเท่านั้น และเราสามารถใช้ tool นี้ในการ generate EJB 3.0 ได้ง่ายขึ้นด้วย เพราะว่ามันจะช่วยเราในเรื่องการทำ mapping entity ได้ง่ายขึ้นด้วย ลองทำตามดูตาม link เลยครับ

Spring

เป็น plug-in ที่ช่วยสอดประสานระหว่าง JPA และ Spring DAO ได้ดีทีเดียว มี tool ช่วย generate ให้ซึ่งลองทำตามได้ตาม link นี้ครับ

สรุป

ผมให้ความสามารถของ plug-in ตัวนี้ 9/10 ครับ เหมาะมากสำหรับการทำ Java EE Application นอกจากนี้ document สอนการใช้ tool ค่อนข้างละเอียดแถมมี vdo การสอนด้วย เป็น step ดีมาก

Ref :

• OTN
  
• Oracle Documents
  
• InfoQ
  

ข้อเขียนนี้ช่วยฉัน:

XWT: version ใหม่ของ SWT ที่น่ามอง

XWT นั้นเป็น SWT ธรรมดาตัวหนึ่งเพียงแต่ว่าแยกส่วนของ view ออกมาไว้ใน xml ส่วน model และ controller นั้นยังอยู่ใน code java เหมือนเดิม ซึ่งโดยปกติที่เราเขียน SWT ถึงแม้ว่าเราเขียนใน code java ทั้งหมดแต่เราก็สามารถแยก model, view และ controller ออกได้เองอยู่แล้ว เพียงแต่ XWT นั้นช่วยทำให้มันเห็นเด่นชัดมากขึ้นนั้นเอง

การ design หน้า view ของ XWT

<Shell xmlns="http://www.eclipse.org/xwt/presentation"
  xmlns:x="http://www.eclipse.org/xwt">
  <Shell.layout>
    <FillLayout/>
  </Shell.layout>
  <Button text="Hello, world!">
  </Button>
</Shell>

* This source code was highlighted with Source Code Highlighter.

แทนที่การ design หน้า view ของ SWT

Shell parent = new Shell();
parent.setLayout(new FillLayout());
Button button = new Button(parent, SWT.NONE);
button.setText("Hello, world!");

* This source code was highlighted with Source Code Highlighter.

จะเห็นว่ามันง่ายมากขึ้นและสามารถ maintain ได้ง่ายขึ้น แต่สำหรับคนที่มองว่าการเขียน xml เป็นเรื่องยุ่งยากให้เราลองมองว่า xml นี้มันเหมือนกับ html ธรรมดา

ซึ่งก่อนที่ eclipse จะทำ XWT ออกมาก็มี plug-in ต่างๆมากมายที่รองรับการเขียนในส่วนของ view ของ SWT ต่างๆในรูปของ xml ไม่ว่าจะเป็น swtxml, CookSwt: XML to SWT GUI, และอื่นๆอีกมากมาย และดูเหมือนในตอนนี้ผมรู้สึกว่า plug-in ของเจ้าอื่นๆยังใช้ง่ายกว่าอีก (หรือเพราะว่ามันเป็นแค่ RT อยู่ทำให้มันขัดใจได้ขนาดนี้) แน่นอนว่า eclipse ทำมาทั้งทีจะแค่นี้ได้อย่างไร โดยผู้ออกแบบนั้นต้องการที่จะให้ XWT นั้นเป็นสื่อกลางของ UI ทั้งหมดที่พร้อมจะ port ไปเป็นอะไรก็แล้วแต่โดยที่ในรูปด้านล่างจะยกตัวอย่างของ SWT และ JFace และดูเหมือนว่าในจะรองรับการ port ออกมาเป็น web ด้วยซึ่งถ้าเป็นเช่นนั้นจริงถือว่าเป็นการเปิดตลาดของ RIA ขึ้นเหมือนกับของ sun ที่เปิดตลาด RIA ด้วย Java FX (มันคล้ายกับ Java มี Swing แต่ Eclipse ออก SWT มาใช้แทน)

ภาพ UI จากที่ port จาก XWT เป็น web


ภาพ UI จากที่ port จาก XWT เป็น swt


โดย vendor ที่เริ่มต้น project นี้คือ soyatec ซึ่งมีหลาย project ซึ่งที่ผมใช้อยู่นั้นคือ euml2 และยังมีอื่นๆอีกเช่น eFace และ eBPMN



โดยแนวคิดนี้ดูเหมือนจะคล้ายกับ XAML ของ M$ มากโดยถ้าหากมันสวยดังรูปที่ demo มาจริงๆหละก็อาจจะมาแทนที่ Java FX เลยก็ได้และเป็นคู่แข่งกับ Flex และ Silverlight ได้อย่างสูสีแต่ ณ ตอนนี้ที่สามารถลองเขียนและ demo ได้จริงนั้นเป็นเพียงแค่ XWT -> SWT เท่านั้นซึ่งผมลองเล่นดูแล้วมันค่อนข้างที่ไม่เหมือนกับภาพด้านบนที่มัน Demo เลยให้ความรู้สึกเหมือน Swing กับ SWT ปกติ ซึ่งอาจเป็นเพราะว่ายังเป็นแค่ RT เท่านั้น

Update :: XWT ที่สามารถ run ทั้งใน desktop application หรือที่ port ออกมาเป็น web application ได้สวยนั้นเพราะว่าใน desktop application นั้นมันจะแปลง XWT เป็น Flex ส่วน web application นั้น XWT จะแปลงเป็น GWT นั้นเอง
RAP ขอโทษครับผิดผลาดอย่างแรง

Update 2 :: ไปลองเล่น demo จริงๆของ XWT ที่ port เป็น RAP ที่นี่

Ref : http://wiki.eclipse.org/E4/XWT, http://dev.eclipse.org/blogs/yvesyang/2008/11/28/xwt-declarative-ui-designed-for-eclipse/, http://wiki.eclipse.org/E4

ปล. http://sourceforge.net/projects/xwt, http://www.xwt.org/ ดูเหมือนว่าจะเป็นคนละ project และไม่เกี่ยวข้องกับ XWT ของ Eclipse เลย

ข้อเขียนนี้ช่วยฉัน: