|
|
领域层类可以理解为程序运行时数据流的功能单位,而服务层类是为领域层类提供服务的,常见的服务有增删改查等操作,在没有泛型之前,我们只能采用一个服务类为一个领域类提供服务的方案,如果说服务的性质类似,如都是增删改查等,则代码的功能重复性很高,维护起来也很麻烦.如果采用了泛型类,我们就可以把性质相似的服务类归纳成一个,很大程度上能简化编码.
下面请看例子,我们有两个领域对象类:
Member类:
 package domain;
import org.dom4j.Element;
  /** *//**
 * 成员类
*
* @author zdw
*
 */
public class Member implements CanbeXmlElementtable
 {
private String name;
private int 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 String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
}
package domain;
import org.dom4j.Element;
/** *//**
* 公司类
* @author zdw
*
*/
public class Company implements CanbeXmlElementtable
{
//公司名
private String name;
//地址
private String 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;
}
@Override
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 domain;
import org.dom4j.Element;
/** *//**
* 接口,强制子类实现generateElement函数
* @author zdw
*
*/
public interface CanbeXmlElementtable
{
public Element generateElement(Element parent);
}
为什么要实现这个接口呢,下面就知道了.
对这两个对象需要实现集中管理和将集合存储到XML文件中,现在我们可以用泛型类实现这两个功能,下面看泛型类实现的新服务类:
package domain;
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;
/**//*
* 服务类,持有对象的集合,负责对象的存储
*/
public class Service<T extends CanbeXmlElementtable>
{
private List<T> elements;
/**//*
*添加集合元素
*/
public void add(T element)
{
if(elements == null)
{
elements = new ArrayList<T>();
}
elements.add(element);
}
/**//*
* 将集合保存成xml文件
*/
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();;
//指定xml编码
format.setEncoding("GBK");
XMLWriter writer = new XMLWriter(new FileWriter(xmlFile),format);
writer.write(document);
writer.close();
} catch (Exception e)
{
e.printStackTrace();
}
}
}
对于两个领域对象的集合管理和XML持久化,使用这一个类就可以了,下面是测试代码:
package domain;
public class Main
{
/** *//**
* @param args
*/
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("src/domain/member.xml");
//泛型类测试二
Service<Company> companyService = new Service<Company>();
companyService.add(new Company("IBM","New York"));
companyService.add(new Company("Microsoft","beijing York"));
companyService.add(new Company("Google","Shanghai"));
companyService.add(new Company("Citigroup","Dalian"));
companyService.saveToXml("src/domain/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>New York</address>
</company>
<company>
<name>Microsoft</name>
<address>beijing York</address>
</company>
<company>
<name>Google</name>
<address>Shanghai</address>
</company>
<company>
<name>Citigroup</name>
<address>Dalian</address>
</company>
</elements>
现在可以看出,以前使用多个类才能实现的功能在泛型类诞生后只需要一个类就可以了,它能高度归纳类的共性,减少功能相似类的数目,减少重复代码,减轻了项目的复杂度,真的是"很好,很强大!".
|