领域层类可以理解为程序运行时数据流的功能单位,而服务层类是为领域层类提供服务的,常见的服务有增删改查等操作,在没有泛型之前,我们只能采用一个服务
类为一个领域类提供服务的方案,如果说服务的性质类似,如都是增删改查等,则代码的功能重复性很高,维护起来也很麻烦.如果采用了泛型类,我们就可以把性
质相似的服务类归纳成一个,很大程度上能简化编码.
下面请看例子,我们有两个领域对象类:
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");
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.blogjava.net/Files/sitinspring/GenericPersistence20071228164755.rar
如果你对泛型类不是很熟悉可以参考:
http://www.blogjava.net/sitinspring/archive/2007/12/28/171212.html
分享到:
相关推荐
通过上述分析,我们可以看出,合理设计和运用泛型DAO层,不仅可以显著提高代码的复用性和维护性,还能极大地简化复杂的数据库操作,使得开发人员能够更加专注于业务逻辑的实现。因此,对于那些追求高质量、高效率的...
为了解决抽象各个Java实体基本的“增删改查”操作,我们通常会以泛型的方式封装一个模板Dao来进行抽象简化,但是这样依然不是很方便,我们需要针对每个实体编写一个继承自泛型模板Dao的接口,再编写该接口的实现。...
总之,泛型DAO是Java开发中一个非常实用的设计模式,它通过泛型提升了代码的复用性,并且与ORM框架结合,能有效简化数据访问层的实现。同时,了解如何阅读和解析XML配置文件也是Java开发者必备的技能之一,特别是在...
在Struts2中,注解的使用可以简化配置,比如`@Action`用于标记Action类,`@Results`定义结果映射,使代码更简洁。 2. **Spring3**:Spring是Java企业级应用的全面解决方案,包括依赖注入(DI)、面向切面编程(AOP...
总的来说,Spring的泛型依赖注入是其IOC功能的一个强大扩展,它增强了代码的灵活性,提供了类型安全的依赖注入,简化了多态服务的配置,使得大型项目中的依赖管理变得更加优雅和高效。通过深入理解和实践这一特性,...
泛型是Java SE 5引入的一种强大的类型系统机制,允许在类、接口和方法中使用类型参数,从而增强了代码的类型安全性和重用性。在Spring框架中,泛型主要应用于依赖注入(Dependency Injection,简称DI),这是Spring...
在Spring框架中,可以通过配置将这个实现类注入到需要的地方,例如Service层,以完成对数据库的操作。 总结起来,`Hibernate泛型DAO`提供了一种统一的方式来处理不同实体的数据库操作,简化了代码,提高了代码的...
1)dao类的繁多,很多设计都是一个entity对应一个dao (不同的只有类名和方法名) 2)dao接口需要维护的method庞大。 3)业务逻辑改变时,dao需要同时修改两个类文件(接口和实现类) 在本文中,我将为您展示如何...
在S2SH整合中,比如在Spring中可以使用`@Component`、`@Service`、`@Repository`、`@Controller`等注解声明Bean,而Hibernate可以通过`@Entity`、`@Table`、`@Id`等注解定义实体类。 5. **JSON**:JavaScript ...
- 编写Service层:调用DAO接口实现业务逻辑,处理分页参数。 - 创建Struts2 Action:接收用户请求,调用Service方法,将分页数据传递给视图层。 - 设计视图:使用JSP或其他模板引擎展示分页结果,通常包含上一页、...
这个基于Spring MVC和MyBatis的泛型代码生成模板就是为此目的设计的。 首先,Spring MVC是一个模型-视图-控制器(MVC)架构模式的实现,它使得开发者能够将业务逻辑、数据模型与用户界面分离,提高了代码的可维护性...
泛型DAO(Data Access Object)是一种设计模式,它的目标是通过泛型将业务对象与数据访问逻辑分离,使得DAO层能够适应多种类型的实体类。在Struts2+Hibernate+Spring的集成中,泛型DAO扮演着重要的角色,它使得DAO层...
现在,我们可以直接在Service层的接口或类中指定泛型类型,从而让Spring在配置时能根据类型匹配自动注入正确的DAO实例。这减少了手动设置类型转换的需要,也避免了因类型不匹配导致的错误。 以下是使用Spring 4.0...
在Spring框架中,注解扮演着至关重要的角色,它们简化了配置,减少了XML配置文件的使用。例如,`@Component`、`@Service`、`@Repository`和`@Controller`用于标记组件,`@Autowired`用于自动装配依赖,`@Qualifier`...
标题中的“hibernate4 通用dao,service”指的是在Java开发中使用Hibernate框架实现的通用数据访问对象(DAO)和业务服务层(Service)。Hibernate是一个流行的对象关系映射(ORM)工具,它允许开发者使用面向对象的...
4. 服务层(Service Layer)提供了跨组件的通信接口,使不同层之间能有效协作。5. 领域模型层(Domain Model Layer)封装了业务对象和业务规则。6. 基础设施层(Infrastructure Layer)包含非核心功能,如日志、邮件...
2、采用Jsp->Action->Service->Dao的编码方式,封装了HibernateUtil、SpringUtil、HqlUtil等工具,以及简化了增删查改操作。 3、此底层包含泛型DAO、Proxool连接池、国际化语言、DateUtil工具、ExcelUtil报表工具、...
ASP.NET AJAX 提供了一种强大的机制,使得开发者可以方便地在客户端JavaScript中异步调用Web Service和页面中的类方法,极大地简化了原本复杂的Ajax通信。这一特性是ASP.NET AJAX框架的核心优势之一,它允许开发者...
泛型DAO(Data Access Object)是一种设计模式,用于抽象数据访问层的操作,提供通用的CRUD(Create, Read, Update, Delete)方法。通过泛型,DAO可以适用于多种类型的实体,降低了代码重复。例如,一个BaseDAO接口...
3. **使用泛型**:在DAO接口和实现类中使用泛型,可以提高代码的复用性,避免类型转换的麻烦。例如,定义一个通用的BaseDAO接口,包含通用的CRUD方法,然后根据具体的数据实体创建继承自BaseDAO的特定DAO类。 4. **...