領域層類可以理解為程序運行時數據流的功能單位,而服務層類是為領域層類提供服務的,常見的服務有增刪改查等操作,在沒有泛型之前,我們只能采用一個服務類為一個領域類提供服務的方案,如果說服務的性質類似,如都是增刪改查等,則代碼的功能重復性很高,維護起來也很麻煩.如果采用了泛型類,我們就可以把性質相似的服務類歸納成一個,很大程度上能簡化編碼.
下面請看例子,我們有兩個領域對象類:
Member類:
package com.sitinspring.domain;
import org.dom4j.Element;
/** *//**
* 成員類
* @author sitinspring
*
* @date 2007-12-28
*/
public class Member implements CanbeXmlElementable
{
// 成員名稱
private String name;
// 年齡
private int age;
/** *//**
* 構造函數
* @param name
* @param age
*/
public Member(String name,int age){
this.name=name;
this.age=age;
}
/** *//**
* 將Member實例轉化為XML中一個節點
*/
public Element generateElement(Element parent){
Element elm=parent.addElement("member");
Element nameElm=elm.addElement("name");
nameElm.setText(name);
Element ageElm=elm.addElement("age");
ageElm.setText(String.valueOf(age));
return elm;
}
public String toString(){
return "Name="+name+" Age="+age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
公司類:
package com.sitinspring.domain;
import org.dom4j.Element;
/** *//**
* 公司類
* @author sitinspring
*
* @date 2007-12-28
*/
public class Company implements CanbeXmlElementable{
// 公司名
private String name;
// 地址
private String address;
/** *//**
* 構造函數
* @param name
* @param address
*/
public Company(String name,String address){
this.name=name;
this.address=address;
}
/** *//**
* 將Company類的實例轉化為XML的一個節點
*/
public Element generateElement(Element parent){
Element elm=parent.addElement("company");
Element nameElm=elm.addElement("name");
nameElm.setText(name);
Element ageElm=elm.addElement("address");
ageElm.setText(address);
return elm;
}
public String toString(){
return "Company Name="+name+" Address="+address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
它們都實現了一個名為CanbeXmlElementable的接口:
package com.sitinspring.domain;
import org.dom4j.Element;
/** *//**
* 接口,強制子類實現generateElement函數
* @author sitinspring
*
* @date 2007-12-28
*/
public interface CanbeXmlElementable{
/** *//**
* 用于把領域對象實例轉化為XML中一個節點
* @param parent
* @return
*/
public Element generateElement(Element parent);
}
為什么要實現這個接口呢,下面就知道了.
對這兩個對象需要實現集中管理和將集合存儲到XML文件中,現在我們可以用泛型類實現這兩個功能,下面看泛型類實現的新服務類:
package com.sitinspring.service;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import com.sitinspring.domain.CanbeXmlElementable;
/** *//**
* 服務類,持有對象的集合,負責對象的存儲
* @author sitinspring
*
* @date 2007-12-28
*/
public class Service<T extends CanbeXmlElementable>{
private List<T> elements;
/** *//**
* 添加集合元素
* @param element
*/
public void add(T element){
if(elements==null){
elements=new ArrayList<T>();
}
elements.add(element);
}
/** *//**
* 將集合保存成XML文件
* @param xmlFile
*/
public void saveToXml(String xmlFile){
try{
Document document=DocumentHelper.createDocument();
Element root=document.addElement("elements");
for(T t:elements){
t.generateElement(root);
}
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("GBK"); // 指定XML編碼
XMLWriter writer = new XMLWriter(new FileWriter(xmlFile),format);
writer.write(document);
writer.close();
}
catch(Exception ex){
ex.printStackTrace();
}
}
}
對于兩個領域對象的集合管理和XML持久化,使用這一個類就可以了,下面是測試代碼:
package com.sitinspring;
import com.sitinspring.domain.Company;
import com.sitinspring.domain.Member;
import com.sitinspring.service.Service;
/** *//**
* 測試類
*
* @author sitinspring
*
* @date 2007-12-28
*/
public class Main {
public static void main(String[] args) {
// 泛型類測試一
Service<Member> memberService = new Service<Member>();
memberService.add(new Member("Andy", 25));
memberService.add(new Member("Bill", 35));
memberService.add(new Member("Cindy", 45));
memberService.add(new Member("Sitinspring", 55));
memberService.saveToXml("member.xml");
// 泛型類測試二
Service<Company> companyService = new Service<Company>();
companyService.add(new Company("IBM","NewYork"));
companyService.add(new Company("Microsoft", "beijing"));
companyService.add(new Company("Google", "Shanghai"));
companyService.add(new Company("Citigroup", "Dalian"));
companyService.saveToXml("company.xml");
}
}
文件結果:
member.xml:
<?xml version="1.0" encoding="GBK"?>
<elements>
<member>
<name>Andy</name>
<age>25</age>
</member>
<member>
<name>Bill</name>
<age>35</age>
</member>
<member>
<name>Cindy</name>
<age>45</age>
</member>
<member>
<name>Sitinspring</name>
<age>55</age>
</member>
</elements>
company.xml:
<?xml version="1.0" encoding="GBK"?>
<elements>
<company>
<name>IBM</name>
<address>NewYork</address>
</company>
<company>
<name>Microsoft</name>
<address>beijing</address>
</company>
<company>
<name>Google</name>
<address>Shanghai</address>
</company>
<company>
<name>Citigroup</name>
<address>Dalian</address>
</company>
</elements>
現在可以看出,以前使用多個類才能實現的功能在泛型類誕生后只需要一個類就可以了,它能高度歸納類的共性,減少功能相似類的數目,減少重復代碼,減輕了項目的復雜度,真的是"很好,很強大!".
代碼下載:
http://www.aygfsteel.com/Files/sitinspring/GenericPersistence20071228164755.rar
如果你對泛型類不是很熟悉可以參考:
http://www.aygfsteel.com/sitinspring/archive/2007/12/28/171212.html