public static final int APPLE_FUJI = 0;
public static final int APPLE_PIPPIN = 1;
public static final int APPLE_GRANNY_SMITH = 2;

มาดูข้อเสียของมันดีกว่า
1. มันไม่ type safety
เราสามารถจะ assign ค่าอะไรให้มันก็ได้

2. มันไม่มี namespaces
โดยเราต้องใช้ parameter name ที่มี prefixe เหมือนกันในการจักกลุ่ม

3. มันเป็น compile-time constant
ถ้า build client หรือ class ที่เรียกใช้มัน มันจะ build โดยไปเอาค่า
constant มาเก็บไว้ที่ class มันเลย ลองดูตัวอย่างนี้หน่อยดีกว่า

int enum pattern “Apple.java”

public interface Apple{
	public static final int APPLE_FUJI = 0;
	public static final int APPLE_PIPPIN = 1;
	public static final int APPLE_GRANNY_SMITH = 2;
}

class ที่ต้องการใช้ constant ก็ impliments มา “TestApple.java”

public class TestApple implements Apple{
	public static void main(String[] args) {
		System.out.print(APPLE_FUJI);
		System.out.print(APPLE_PIPPIN);
		System.out.print(APPLE_GRANNY_SMITH);
	}
}

ค่าที่ได้จะเป็น 012 นะครับ แต่ถ้าลองแก้ไขค่าของ constant ของ Interface Apple แล้ว build ใหม่(build แต่ Interface Apple นะครับ)แล้วลอง run class TestApple ค่าที่ได้ก็จะได้ค่าเหมือนเดิม แต่ถ้าอยากได้ค่า constant ใหม่ก็ต้อง build class TestApple ใหม่ด้วยเพื่อให้มันไปอ่านค่า constant มาใหม่

4. มัน print value ของ constant ได้เท่านั้น
เวลา print ออกมาจะได้แต่ค่าที่ constant เก็บไว้เท่านั้นนะครับ

หรืออาจจะเจอ pattern คล้ายๆกัน โดย constant เก็บค่า String เรียกว่า string enum constant แต่มันจะนำไปสู่ปัญหาของ performance ยิ่งกว่านั้นมันทำให้ programmer สามารถ hard-code value ของ string constant แทนการใช้ field name และมันจะมีโอกาศพิมพ์ผิด มันจะเกิดข้อผิดพลาดตอน runtime ทั้งๆที่ มันสามารถค้นหา ข้อผิดพลาดได้ตอน compile time

java5 แก้ไขปัญหาของ pattern นี้ โดยการนำ enum มาใช้

	public enum Apple { FUJI, PIPPIN, GRANNY_SMITH }
	public enum Orange { NAVEL, TEMPLE, BLOOD }

ความแตกต่างที่สำคัญ ของ enum ในภาษา java กับภาษาอื่นใน java enum เป็น class ในขณะที่ภาษาอื่น เช่น C, C++, and C# เก็บข้อมูลเป็น int ลักษณะของ enum ในภาษา java คือเป็น class ที่ export instance ของแต่ละ constanct ที่ประกาศใน enum นั้นโดยทาง “public static final field”

1. type safety
เราสามารถจะ assign ค่าที่ประกาศไว้ใน enum เท่านั้น

2. namespaces
แก้ปัญหา named constants เพราะ enum มี namespace (ก็ชื่อของมันเอง)

3. มันไม่ได้ เอาค่า constant มาเก็บไว้แต่มันจะ reference ไปแทน
สามารถแก้ไขหรือ เพิ่ม constants โดยไม่ต้อง build class ที่เรียกใช้มันใหม่
เหมือนกับว่าตอน build มันไม่ได้เอาค่า constant มาเก็บไว้ที่ class ของมันเลยแต่จะสร้าง reference ไปหา class enum แทน

4. เราสามารถ print ชื่อ constant, value หรือค่าอะไรก็ได้ที่เกี่ยวข้องกับ constant method toString ของมันจะ return ชื่อของ constant หรือถ้าไม่ต้องการชื่อ constant เราก็ยังสามารถ override method toString ได้แล้ว get ข้อมูลของแต่ละ enum มาได้ด้วยนะครับ

5. can use == operation

6. สามารถเพิ่ม method หรือ property ที่มีความสำพันธ์กับ constant ได้

มาดูตัวอย่างกันดีกว่า
จัดกลุ่ม constant ของ Apple จากตัวอย่างข้างบน enum “Apple.java”

	FUJI(0, "ฟูจิ"), PIPPIN(1, "พิพพิน"), GRANNY_SMITH(2, "แกรนนี่ สมิท");
	private Integer appleType;
	private String description;

	Apple(Integer appleType, String description) {
		this.appleType = appleType;
		this.description = description;
	}

เริ่มด้วยการกำหนดชื่อ constant “FUJI” ส่ง parameter ไป 2 ตัวคือ value และ description ของมันไปทาง constructor เป็นการผูก constant name, value, description เข้าด้วยกัน
เพิ่ม method

	public Integer getAppleType() {
		return appleType;
	}
	public String getDescription() {
		return description;
	}

เพิ่ม method “getApples()” เพื่อเอาไว้ get instant ของ enum ทั้งหมด

	public static List getApples() {
		return Arrays.asList(Apple.values());
	}

เพิ่ม method getApple(Integer appleType)” เพื่อเอาไว้ get instant โดย value

	public static Apple getApple(Integer appleType) {
		List apples = getApples();
		for (Apple apple : apples)
			if (appleType.compareTo(apple.getAppleType()) == 0)
				return apple;
		throw new AssertionError("Unknown Apple type : " + appleType);
	}

มาลอง test กันดีกว่า “Test.java”
สามารถ get instanct ทั้งหมดได้

	List apples = Apple.getApples();
	for (Apple apple : apples)
		log.debug(apple);

สามารถ get ค่าอื่นๆที่มีความสำพันธ์กับ constant ได้

	Apple apple1 = Apple.FUJI;
	log.debug(apple1);
	log.debug(apple1.getAppleType());
	log.debug(apple1.getDescription());

สามารถ get instanct โดย value ของมันได้

	Apple apple2 = Apple.getApple(0);

สามารถใช้ operation == ได้

	log.debug(apple1 == apple2);

org.hibernate.QueryException: ClassNotFoundException: org.hibernate.hql.ast.HqlToken

ก็เลยลองถามอาจารย์กูดู สรุปว่า
เกิดจากการ conflicts กันระหว่าง libraries TopLink กับ libraries Hibernate

การแก้ปัญหาก็คือเอา libraries ของ TopLink ออก
โดยการแก้ไข file orion-application.xml ของ application โดยเพิ่ม tag

<imported-shared-libraries>
	<remove-inherited name="oracle.toplink"/>
</imported-shared-libraries>

แต่ปัญหานี้ก็ยังไม่จบนะครับ เพราะทุกครั้งที่ publish มันก็จะลบ application
ออกแล้วเราก็จะได้ orion-application.xml ใหม่ (ก็คือเป็นเหมือเดิม)

การแก้ไขก็ แก้ไขที่ Configure Class Loading
Example: Removing an Oracle Shared Library at Deployment Time
จะทำให้ทุกครั้งที่ publish จะได้มันจะได้ไม่ import libraries ของ TopLink
ไปด้วยครับ

	String CONSTANT_VALUE = "constantValue";

มันก็จะเป็น

	public static final String CONSTANT_VALUE = "constantValue";

ด้วยเหตุที่มันเป็น final เสมอเราก็ต้อง assign ค่าให้มันเสมอ อีกเช่นกัน
(ดูดิมันช่างเหมาะจะเอาไว้เก็บ constant จริงๆ)

แล้ว java ก็ extends ได้ 1 class แต่ implements ได้หลาย interface
มันก็ดูจะเข้าท่าดีนะที่จะเขียน interface ไว้เก็บ constant เพราะเวลาเรา
implements interface นี้แล้ว ก็สามารถใช้ constant ใน interface ได้ทันที
subclass ก็สามารถใช้ได้ทันทีเช่นกัน และยังสามารถ extends class อื่นได้อีก

มันจึงเกิด pattern (antipattern) หนึ่ง ชื่อว่า interface constant

ลักษณะก็จะมีแต่ property และไม่มีการประกาศ method ให้ class ที่
implement ไปต้อง implements อะไรเลย class ที่จะใช้ constant
ก็ implements constant interface และเพื่อจะหลีกเลี่ยงการอ้าง
ถึง constant ด้วย namespace

public interface PhysicalConstants {
	static final double AVOGADROS_NUMBER = 6.02214199e23;
	static final double BOLTZMANN_CONSTANT = 1.3806503e-23;
}

“The constant interface pattern is a poor use of interfaces.”

ถ้าดูให้ดีแล้วนะครับถ้า class ที่ implements constant interface ไม่ได้เป็น final (ซึ่ง final class ก็เป็นอะไรที่ไม่ควรเขียนอีก) ซึ่งมันอาจจะถูก extends ได้อีก sub class ของมัน ก็สามารถอ้าง constant interface ได้ แล้วถ้าวันหน้า class ที่ implements นี้มาโดยตรงไม่จำเป็นต้องใช้ constant นี้แล้ว !!แต่ก็ยังต้อง implements อยู่ดีเพราะ sub class ของมันอาจจะใช้ constant อยู่

แล้วขณะที่บาง sub class ไม่จำเ็ป็นต้องใช้ constant
ก็จะสามารถอ้างถึง constant ได้ทั้งที่ไม่จำเป็น

ถ้าต้องการใช้ constant ทางเลือกคือ

เขียน utilities class เพื่อเก็บ constant แล้วหลีกเลี่ยงการอ้างถึง constant
ด้วย namespace โดยใช้ static import

import static PhysicalConstants.*;
public class Test {
	double atoms(double mols) {
		return AVOGADROS_NUMBER * mols;
	}
}

หรือถ้ามันควรจะอยู่ที่ interface ก็ได้ถ้ามองว่า class ที่ implements นี้ไป
ควรใช้ constant เหมือนกัน (แต่ให้คิดว่าใช้ interface เป็นการประกาศชนิดของ class ก่อนส่วนจะมี constant มันก็เป็นอีกเรื่องหนึ่ง ไม่ใช่เขียน interface เพื่อที่จะเก็บ constant ก่อน )

“interfaces should be used only to define types.”
They should not be used to export constants.

reference : Effective Java

Librarise :
aopalliance.jar
aspectjrt.jar
aspectjweaver.jar
cglib-nodep-2.1_3.jar
commons-*.jar
dom4j-1.6.1.jar
hibernate3.jar
hibernate-*.jar
junit.jar
log4j-1.2.13.jar
ojdbc14.jar
spring-*.jar

Database : Oracle 10g

เริ่มต้นด้วย การ configure pool “Datasource” กันเลยดีกว่า
Spring ไม่มี pool data source นะครับ เราก็เลยต้องไปใช้ data source
ของ Jakarta Commons ที่ชื่อว่า BasicDataSource หรือจะใช้ ComboPooledDataSource ก็ได้นะครับ
Spring มี connection 2 อันนะครับ คือ
1. DriverManagerDataSource จะ return connection ใหม่ทุกครั้งที่มีการเรียกใช้
2. SingleConnectionDataSource มี connection อันเดียว ทุกครั้งที่เรียกจะได้ connection อันเดิมเสมอ
(เขียนไปงั้น ไม่น่าใช้ทั้งคู่อะ)

ตัวอย่างผมใช้ BasicDataSource นะครับ

<bean id="dataSource"
	class="org.apache.commons.dbcp.BasicDataSource">
	<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
	<property name="url" value="jdbc:oracle:thin:@192.168.1.101:1521:orcl" />
	<property name="username" value="xxxx" />
	<property name="password" value="xxxx" />
	<property name="initialSize" value="5" />
	<property name="maxActive" value="10" />
</bean>

ค่าที่ set ให้กับ property ก็เหมือนกับการที่ set ให้กับ connection pool ทั่วไปนะครับ

“sessionFactory” ขอยกตัวอย่างโดยการใช้ xml mapping file ธรรมดา
เราก็ต้องใช้ LocalSessionFactoryBean ของ spring ในการสร้าง sessionFactory

<bean id="sessionFactory"
	class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
	<property name="mappingResources">
		<list>
			<value>domain/Signon.hbm.xml</value>
		</list>
	</property>
	<property name="hibernateProperties">
		<props>
			<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
		</props>
	</property>
</bean>

โดยจะ inject dataSource ที่เราพึ่งสร้างไปให้มันด้วย
property mappingResources : เป็น List เอาไว้กำหนด path ของ
mapping files ที่ต้องการให้มัน map Domain Class กับ Table
property hibernateProperties : เป็น prop เอาไว้กำหนดค่า config ต่างของ hibernate session

“hibernateTemplate” หน้าที่หลักของ hibernateTemplate
คือ open,close hibernateSession และแปลง hibernateException เป็น
Data access Exception ของ Spring ที่เป็น uncheck Exception ทั้งหมด

<bean id="hibernateTemplate"
	class="org.springframework.orm.hibernate3.HibernateTemplate">
	<property name="sessionFactory" ref="sessionFactory" />
</bean>

inject sessionFactory เข้าไปให้มัน

Table ที่ใช้เอามาจาก ตัวอย่าง jpetstore ของ spring ชื่อ Table “signon”
ผมมาแก้ไขนิดหน่อย โดยเพิ่ม field signon_gen เป็น surrogate key
(ไม่เกี่ยวกันตัวอย่างที่ผมจะทำหลอกนะครับ เพียงแต่เห็น Table ไหนไม่มี
surrogate key แล้วมันขัดใจยังไงไม่รู้)
Domain Class “Signon.class”

package domain;
public class Signon implements java.io.Serializable {
	private Long signonGen;
	private String username;
	private String password;
	public Signon() {
	}
	public Signon(String username, String password) {
		this.username = username;
		this.password = password;
	}
	// stripped out the accessor method and mutator method
}

Hibernate XML Mappings “signon.hbm”

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="domain.Signon" table="SIGNON" schema="SYSTEM">
	<id name="signonGen" type="java.lang.Long">
		<column name="SIGNON_GEN" precision="22" scale="0" />
		<generator  class="assigned"  />
	</id>
	<property name="username" type="java.lang.String">
		<column name="USERNAME" length="25" not-null="true" />
	</property>
	<property name="password" type="java.lang.String">
		<column name="PASSWORD" length="25" not-null="true" />
	</property>
</class>
</hibernate-mapping>

Data Access Object (DAO) “SignonDao.class”,”SignonDaoImpl.class”

package dao;
public interface SignonDao {
	public Signon findByUsername(String username) ;
}
package dao;
// stripped out the import statement
public class SignonDaoImpl extends HibernateDaoSupport implements SignonDao {
	public Signon findByUsername(String username) {
		String hql = " from Signon s where s.username = :username ";
		List signons = (List)
			getHibernateTemplate().findByNamedParam(hql, "username", username);
		return signons != null ? signons.get(0) : null;
	}
}

DAO นี้มี method เดียวนะครับ คือ findByUsername เอาไว้ค้นหา User จาก username
ตัวอย่าง เขียน hql ค้นหา class Signon where ด้วย username
แล้ว getHibernateTemplate ที่ได้มาจากการ extends HibernateDaoSupport ของ Spring
แล้วใช้ method findByNamedParam จาก hibernateTemplate ส่ง parameter ไป 3 ตัว คือ
1. hql : hql
2. “username” : ชือ parameter ใน hql ที่ต้องการ binding parameter
3. username : value ที่ต้องการ binding
จะได้ return กลับมาเป็น List ของ Object แล้วก็มา cast เป็น List<Signon>

สร้าง instance signonDao

<bean id="signonDao" class="dao.SignonDaoImpl">
	<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>

โดยส่ง hibernateTemplate เข้าไปด้วย
หรือจะฉีด sessionFactory เข้าไปใน class ที่ extends HibernateDaoSupport
เลยก็ได้นะครับ ตอนนี้เราก็มี Dao พร้อมใช้งานแล้วครับ
(class ที่ extends มาจาก HibernateDaoSupport จะได้รับการสืบทอด ็็setHibernateTemplate,setSessionFactory มาด้วย )

Data Access Context “application-data.xml”
เสร็จแล้วหน้าตาของ context ของ Data access Layer จะมีหน้าตาแบบนี้นะครับ

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- config data source and hibernate session -->
<bean id="dataSource"
	class="org.apache.commons.dbcp.BasicDataSource">
	<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
	<property name="url" value="jdbc:oracle:thin:@192.168.1.101:1521:orcl" />
	<property name="username" value="xxxx" />
	<property name="password" value="xxxx" />
	<property name="initialSize" value="5" />
	<property name="maxActive" value="10" />
</bean>
<bean id="sessionFactory"
	class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
	<property name="mappingResources">
		<list>
			<value>domain/Signon.hbm.xml</value>
		</list>
	</property>
	<property name="hibernateProperties">
		<props>
			<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
		</props>
	</property>
</bean>
<bean id="hibernateTemplate"
	class="org.springframework.orm.hibernate3.HibernateTemplate">
	<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- config data source and hibernate session -->
<!-- declare DAO -->
<bean id="signonDao" class="dao.SignonDaoImpl">
	<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>
<!-- declare DAO -->
</beans>

มาถึงตอนนี้ resource ของ Data access Layer ก็เสร็จหมดแล้วนะครับ
มาต่อกันที่ Service Layer ดีกว่า

Service Object (หรือ BO) “UserService .class”,”UserServiceImpl .class”

package service;
public interface UserService {
	public Signon signon(String userName, String password);
}
package service;
public class UserServiceImpl implements UserService {
	SignonDao signonDao;
	public UserServiceImpl(SignonDao signonDao) {
		this.signonDao = signonDao;
	}
	public Signon signon(String userName, String password) {
		if (GenericValidator.isBlankOrNull(username))
			throw new IllegalArgumentException();
		if (GenericValidator.isBlankOrNull(password))
			throw new IllegalArgumentException(); 

		Signon signon = signonDao.findByUsername(username);
		return signon != null && signon.getPassword().equals(password ) ? signon : null ;
	}
}

Service นี่ก็มี method เดียวเหมือนกัน คือ signon
ก่อนอื่นก็ validate ก่อนเลยนะครับ
แล้วก็ส่ง username ไปค้นหา Object Signon return ออกไป

transactionManager:

<bean id="transactionManager" class="orm.hibernate3.HibernateTransactionManager">
	<property name="sessionFactory" ref="sessionFactory" />
</bean>

สร้าง instance ของ HibernateTransactionManager โดยส่ง sessionFactory เข้าไป
(instance เดียวกับ ที่ฉีดเข้าไปใน HibernateTemplate )

tag tx:advice:

<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<tx:attributes>
		<tx:method name="signon" propagation="REQUIRED" />
	</tx:attributes>
</tx:advice>

tx:method ใช้กำหนดรายละเอียดของ Transection ของแต่ละ Method

tag aop:config:

<aop:config>
	<aop:pointcut id="userServiceOperation"
		expression="execution(* *..UserServiceImpl.*(..))" />
	<aop:advisor pointcut-ref="userServiceOperation" advice-ref="txAdvice" />
</aop:config>

pointcut ใช้ AspectJ ประกาศ expression ที่จะ control Transection

userService:

<bean id="userService" class="service.UserServiceImpl">
	<constructor-arg ref="signonDao" />
</bean>

สร้าง instance UserServiceImpl ส่ง signonDao เข้าไป

Service Context “application-service.xml”
เสร็จแล้วหน้าตาของ context ของ Service Layer จะมีหน้าตาแบบนี้นะครับ

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd

http://www.springframework.org/schema/tx

	http://www.springframework.org/schema/tx/spring-tx.xsd">

<!-- declare transection -->
<bean id="transactionManager" class="orm.hibernate3.HibernateTransactionManager">
	<property name="sessionFactory" ref="sessionFactory" />
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<tx:attributes>
		<tx:method name="signon" propagation="REQUIRED" />
	</tx:attributes>
</tx:advice>

<aop:config>
	<aop:pointcut id="userServiceOperation"
		expression="execution(* *..UserServiceImpl.*(..))" />
	<aop:advisor pointcut-ref="userServiceOperation" advice-ref="txAdvice" />
</aop:config>
<!-- declare transection -->

<!-- declare service -->
<bean id="userService" class="service.UserServiceImpl">
	<constructor-arg ref="signonDao" />
</bean>
<!-- declare service -->
</beans>

UnitTest “UnitTest.class”

package test;
public class UnitTest {
	Logger log = LogManager.getLogger(this.getClass());
	@Test
	public void test() {
		String[] contextFile = { "application-data.xml", "application-service.xml" };
		ApplicationContext context = new ClassPathXmlApplicationContext(contextFile);
		UserService userService = (UserService) context.getBean("userService");
		Signon signon = userService.signon("j2ee", "j2ee");
		log.debug(signon.getUsername() + signon.getPassword());
	}
}

กำหนด context file ของ spring ที่จะใช้งาน
create instance ClassPathXmlApplicationContext ส่ง array ที่เก็บ ชื่อของ context file เข้าไป
(ClassPathXmlApplicationContext มันจะไปหา file ที่ส่งเข้าไปจาก classPath)
return ออกมาเป็น ApplicationContext แล้วก็ Get Bean ที่ต้องการใช้งาน

ตอนแรกว่าจะยกตัวอย่างจาก Effective Java แต่อ่านแล้วงงๆ อ่านยาก
ตัวอย่างอ่านแล้วไม่ค่อยเห็นภาพเท่าไหร่ เลยเอาตัวอย่างจาก Head First Design Pattern ดีกว่า

เป็น ตัวอย่างที่อธิบายเรื่อง Strategy Pattern แต่เนื้อหาพูดถึงเรื่อง การใช้
composition แทนการใช้ inheritence ได้ดีทีเดียว ผมจะ focus เรื่องการใช้
composition แทน inheritance ยังไง และทำไมการใช้ inheritance
ถึงไม่สมควรทำ(จริงๆแล้ว พื้นฐานการออกแบบก็สำคัญกว่า Pattern ต่างอยู่แล้วหละครับ)

ตัวอย่าง พูดถึง duck simulation game ที่เป็ดมีความสามารถหลากหลาย
เช่น swim,quack การออกแบบ เริ่มต้นคือการ เขียน superclass เป็น class
ต้นแบบของเป็ด(Duck) แล้วก็ให้เป็ดแต่ละชนิด extends ไป

public abstract class Duck {
abstract void display();
	public void quack() {
	}
	public void swim() {
	}
}

ต่อมาก็มีความต้องการให้เป็ด บินได้ ก็ไม่ยากอะไรครับ ก็เพิ่ม method fly
ที่ Class Duck,subclass ที่ extends ไปก็ได้รับการ สืบทอด method fly

	public void fly() {
	}

ต่อมาก็มีความต้องการ เป็ดตัวใหม่ ก็ไม่น่าจะยากอะไรครับ ก็ extends Class Duck ไป
แต่เป็ดที่ต้องการเป็น “robber duckies”(robber duckies เป็นเป็ดที่ ร้องไม่ได้ )
ปัญหาก็เริ่มเกิดแล้วครับ เพราะ เป็ดทุกตัวที่ extends Duck จะได้รับการ สืบทอด method quack

หรือแม้กระทั่ง method fly ที่พึ่งเพิ่มเข้าไป subclass ของ Duck ก่อนหน้านี้
ก็ไม่เคยมีความต้องการ method fly เลย

” เมื่อคุณเพิ่ม method ที่ super class ก็เท่ากับว่าคุณเพิ่ม method ที่ไม่สมควรให้กับ บาง subclass “

“What he thought was a great use of inheritance for the
purpose of reuse hasn’t turned out so well when it comes to maintenance “

ทำไงดี ก็ต้องไป overide method ที่ไม้ต้องการ ให้มันไม่ต้องทำงานอะไร
ก็ดูเหมือนดีนะครับแต่แค่คิดก็เหนื่อยแล้วครับ ต้องทำ subclass ทุกตัวที่
extends Duck (เป็ดตัวไหนไม้ต้องการให้ทำอะไรก็ตาม overide เอา)

	@Overide
	public void fly(){
		//...
	}

ถ้ามีเป็ด 5 ตัวที่บินไม่ได้ ก็ต้อง copy paste ไปทุกตัวก็เริ่ม douplicated code

ทำไงดี สร้าง interface สำหรับ method ที่บาง subclass ไม่ต้องการ
แล้วถ้า subclass ไหนต้องการ method นี้ก็ให้ implement ไป

public abstract class Duck {
	abstract void display();
		public void swim() {
	}
}
public interface FlyAble {
	public void fly();
}
public interface QuackAble {
	public void quack();
}

เป็ดทุกตัวต้อง extends Duck แล้วถ้าตัวไหนต้องการให้ fly หรือ quack
ก็ implement FlyAble หรือ QuackAble เอาครับ

ทำแบบนี้ก็ดูเหมือนดีนะครับ แต่ลองคิดดูถ้าเป็ดตัวไหนมีพฤติกรรมการบินที่เหมือนกัน
ก็ต้อง implement method fly เหมือนกัน และมี code เหมือนกัน

public class MallardDuck extends Duck implements FlyAble {
	public void fly(){
		// same perform fly
	}
}
public class RedheadDuck extends Duck implements FlyAble {
	public void fly(){
  		// same perform fly
	}
}

วิธีนี้ทำให้ ไม่สามารถ reuse code ได้นะครับ แต่ที่แย่กว่า คือ douplicated code
ถ้าพฤติกรรมการบินแบบนี้เปลี่ยน ก็ต้องตามแก้ ทุก subclass
“Identify the aspects of your application
that vary and separate them from what stays the same”
ทำไงดี เขียน interface FlyBehavior แล้วก็ให้ fly แต่ละชนิด implements ไป

public interface FlyBehavior {
	public void   fly();
}
public class FlyNoWay implements FlyBehavior {
	public void fly() {
    		System.out.println("I can't fly");
	}
}
public class FlyRocketPowered implements FlyBehavior {
	public void fly() {
		System.out.println("I'm flying with a     rocket");
	}
}

class Duck ก็ถือ reference ของ FlyBehavior แล้วก็เขียน setFlyBehavior
เพื่อรอรับ instance ของ class ที่ implements FlyBehavior ไป
เวลาจะใช้ FlyBehavior ไหนก็ set ให้กับ class Duck

“Program to an interface, not an implementation”

public abstract class Duck {
	FlyBehavior flyBehavior;
	public void setFlyBehavior (FlyBehavior fb) {
		flyBehavior = fb;
	}
	public void performFly() {
		flyBehavior.fly();
	}
}

เสริมนิดๆ อย่างให้มอง interface เป็น type ของ class
เหมือนกับ ที่มอง class เป็น type ของ instance นะครับ
ตรงนี้สำคัญนะครับ จะทำให้ไม่สับสนการเลือกใช้ ระหว่าง
interface กับ abstact class อืม อ่านแล้วงงๆ เดี๋ยวมาเล่าต่อ

การถือ reference ของ FlyBehavior นี้หละครับคือการ composition
การได้มาของ method fly มาจากการที่ FlyBehavior เป็นส่วนประกอบของ
Duck ไม่ใช้ ได้รับจากการสืบทอด

จริงๆแล้ว การเขียน แบบ composition จะสามารถ reuse ได้มากกว่านะครับ
คือถ้าเราเขียน แบบ composition ก็เหมือนกับว่าเราเขียนโปรแกรมเป็น
componance เราสามารถเอา componance เหล่านี้ไป reuse ได้
เรียกว่า componance reuse ไม่ใช้ code reuse
spring ก็ promote การเขียนโปรแกรมให้เป็น componance ด้วย DI

แล้ว dependency ระหว่าง class ก็น้อยกว่ามากครับ
แล้ว code ก็เข้าใจง่ายกว่าด้วยนะครับ

“Favor composition over inheritance”

เขียนไป เขียนมาไม่รู้จะเข้าใจหรือปล่าว เอาว่าน่าจะเห็นประโยชน์ของการใช้ composition แทนการใช้ inheritance บ้างนะครับ

reference :
Effective Java(แค่ประโยคแรกครับ อ่านแล้วชอบเลยเอามาแปะไว้)
Head First Design Pattern

ลักษณะของ Object จะมี method insert, update, delete เพื่อทำงานกับ Table ได Table หนึ่ง หรือ view ได view หนึ่ง และมีโครงสร้างข้อมูลเหมือนกับ row ใน table โดยแต่ละ column จะเป็น attribute ใน object แต่ละ instance จะเก็บข้อมูล 1 row ใน table หรือ view (ก็คล้ายๆกับ Table Data Gateway อะครับมี method insert, update, delete เหมือนกัน เพียงแต่ว่า Row Data Gateway จะเก็บข้อมูลด้วย ก็เหมือนกับเอา domain class กับ Table Data gateway มารวมกัน) โดย pattern นี้จะต้องมี finder object เอาไว้ค้นหาข้อมูล เพราะ method find ไม่ควรอยู่ใน Row Data Gatway (instance ของ Row Data Gatway จะเกิดได้ขึ้นก็ควรมีข้อมูล จาก row ใน base แล้ว)

ถ้าดูให้ดีแล้วนะครับมันก็เท่ากับว่าเอา Data Access Logic ไปใส่ไว้ใน domain class
แล้วก็เขียน finder object ขึ้นมาเพื่อค้นหาข้อมูล ซึ่งก็เท่ากับว่าการใช้ pattern นี้ก็เหมือนกับบังคับให้ใช้ Value Object เพื่อส่งข้อมูลไป presentation layer เพราะ Data Access Logic ไม่ควรไปอยู่ที่ presentation layer

อย่าสับสนระหว่าง Row Data Gateway กับ Rich Domain Model นะครับ
ความแตกต่างชัดเจนคือ Row Data Gateway เป็น anemic domain ที่ใส่
Data Access Logic ลงไป แล้วเอา Business Logic ไปไว้ที่ Transaction Script
ในขณะที่ Rich Domain Model เป็น domain ที่เก็บข้อมูลและใส่ Business Logic
ลงไป แล้วเอา Data Access Logic เอาไปไว้ที่ Data Mapper

Rich Domain Model หาอ่านเอาใน PEAA นะครับเรื่อง Domain Model นั้นหละครับ
Domain Model ของ martin flower rich เสมอไม่มี Anemic Domain Model เลยไม่ได้เขียนถึง แต่ไปเขียนใน bliki ว่า Anemic Domain Model เป็น anti-patterns (กำ ผมก็ใช้อยู่)

แนะนำให้อ่าน PEAA ของ martin flower นะครับมี Pattern ของ Enterprise Application ให้เลือกใช้มากมาย และที่พูดคุยกันในเว็บบอร์ดทั่วไปถ้าพูดถึง Pattern ในหนังสือเล่มนี้มักจะไม่ค่อยอธิบายกันส่วนมากแนะให้ไปอ่านกันเอง (ราวกับว่าทุกต้องมียังไงอย่างนั้น) แต่ที่สำคัญมากๆๆๆ คือหนังสือเล่มนี้เก่ามากแล้วครับอ่านแล้วคนอ่านก็จะเก่าไปด้วยเลยครับ บางอย่างก็มีคนเอามา implement แล้ว Hibernate, EJB, Spring, Struts
ซึ่งก็รู้สึกว่าถ้าได้ใช้ tecnology อยู่แล้วก็ไม่จำเป็นต้องอ่านก็ได้มั้ง (ขี้เกียจอ่าน) หรือจะว่าก็ดีเหมือนกันจะได้ไม่ใช้ tecnology ในทางที่ผิดๆ แต่ก็จะได้รู้ pattern ที่จำเป็นต้องรู้ เช่นเรื่อง Concurrency, Lazy Load แบบดั่งเดิมเป็นยังไง, Money Pattern จะได้คิดตังไม่ผิด

ส่วนผมไม่ได้อ่านทั้งหมดเอาเป็น reference มากกว่า อ่านเท่าที่จำเป็นจำเท่าที่จำได้
มิงั้นตั้งหน้าตั้งตาตะบันอ่านมีหวังหลับแน่นอน ไว้คุ้นๆจะใช้แล้วค่อยมาอ่านดีกว่า

กลายเป็นเชียร์ให้ซื้อหนังสือไปซะงั้น ได้ไงก็ไม่รู้(พิมพ์เพลิน)
reference : PEAA

Table Date Gateway คือ Object ที่ไว้จัดการกับ Database (CRUD) โดยลักษณะของ Object จะมี method find, insert, update, delete เพื่อทำงานกับ Table ได Table หนึ่ง หรือ view ได view หนึ่ง โดยแต่ละ method จะ map input parameter ใส่ SQL แล้วสั่ง excute การทำงานจะเป็นแบบ stateless คือไม่เก็บสถานะไว้ทำงานครั้งเดียวจบ ลักษณะการทำงานการเรียก function ส่วนมากแล้วเวลาใช้ pattern นี้จะใช้ 1 Object ต่อ 1 Table แต่จริงแล้ว สามารถใช้ 1 Object ต่อ 1 view ที่สนใจ หรือ 1 Object ต่อ Table ทั้งหมดใน base ก็ได้ แต่ที่แน่ๆ ใช้ 1 Object ต่อ 1 Domain Class (anemic domain นะ มิใช่ rich domain) หน้าที่หลักของ Table Date Gateway คือจัดการกับ Data Access Logic ไม่ควรมี Business Logic ปน (เคยอ่านเจอว่า สามารถมี Business ปนได้ แต่เท่าที่จำเป็น) แต่ผมว่าไม่ควรมีเลยมากกว่า ยังไงก็แล้วแต่สดวกครับงานใครงานมัน ถ้ามีแล้วทำงานง่ายขึ้น ประสิทธิภาพดีขึ้นก็แล้วแต่ แต่อย่าลืมว่า Table Date Gateway ต้อง Focus การทำงานที่ Data Access Logic

reference : PEAA