欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

程序员文章站 2024-03-12 12:26:32
上一节《ssh框架网上商城项目第1战之整合struts2、hibernate4.3和spring4.2》我们搭建好了struts2、hibernate和spring的开发环...

上一节《ssh框架网上商城项目第1战之整合struts2、hibernate4.3和spring4.2》我们搭建好了struts2、hibernate和spring的开发环境,并成功将它们整合在一起。这节主要完成一些基本的增删改查以及service、dao和action的抽取。
1. service层的抽取
        上一节中,我们在service层简单写了save和update方法,这里我们开始完善该部分的代码,然后对service层的代码进行抽取。
1.1 完善categoryservice层
        对数据库的操作无非是增删改查,首先我们来完善categoryservice层的接口和实现:

//categoryservice接口 
public interface categoryservice extends baseservice<category> { 
 
 public void save(category category); //插入 
 
 public void update(category category);//更新 
 
 public void delete(int id); //删除 
 
 public category get(int id); //获取一个category 
 
 public list<category> query(); //获取全部category 
 
} 

        对categoryservice接口的具体实现:

public class categoryserviceimpl extends baseserviceimpl<category> implements categoryservice { 
 
 private sessionfactory sessionfactory; 
 
 //spring会注进来 
 public void setsessionfactory(sessionfactory sessionfactory) { 
 this.sessionfactory = sessionfactory; 
 } 
 
 protected session getsession() { 
 //从当前线程获取session,如果没有则创建一个新的session 
 return sessionfactory.getcurrentsession(); 
 } 
 
 @override 
 public void save(category category) { 
 getsession().save(category); 
 } 
 
 @override 
 public void update(category category) { 
 getsession().update(category); 
 } 
 
 @override 
 public void delete(int id) { 
 /*第一种方法有个弊端,就是没删除一次得先查询一次 
 object obj = getsession().get(category.class, id); 
 if(obj != null) { 
  getsession().delete(obj); 
 }*/ 
 string hql = "delete category while id=:id"; 
 getsession().createquery(hql) // 
  .setinteger("id", id) // 
  .executeupdate(); 
 } 
 
 @override 
 public category get(int id) { 
 return (category) getsession().get(category.class, id); 
 } 
 
 @override 
 public list<category> query() { 
 string hql = "from category"; 
 return getsession().createquery(hql).list(); 
 } 
} 

1.2 service层抽取实现
完成了categoryservice后,我们来抽取service层的基础实现。思路是这样的:我们抽取一个基础接口baseservice以及基础接口的实现baseserviceimpl,后面开发的时候,如果需要新的service,只需要做两步即可:首先定义一个新的接口xxxservice继承baseservice接口,这个接口可以增加新的抽象方法;然后定义一个新的实现类xxxserviceimpl继承baseserviceimpl并实现xxxservice接口即可。这样更加便于项目的维护。
我们先根据上面的categoryservice接口来创建baseservice接口:

//基础接口baseservice,使用泛型 
public interface baseservice<t> { 
 public void save(t t); 
 
 public void update(t t); 
 
 public void delete(int id); 
 
 public t get(int id); 
 
 public list<t> query(); 
} 

然后再根据categoryserviceimpl实现类创建baseservice接口的实现类baseserviceimpl:

/** 
 * @description todo(公共模块的抽取) 
 * @author eson_15 
 * 
 */ 
@suppresswarnings("unchecked") 
public class baseserviceimpl<t> implements baseservice<t> { 
 
 private class clazz; //clazz中存储了当前操作的类型,即泛型t 
 private sessionfactory sessionfactory; 
 
 public baseserviceimpl() { 
  //下面三个打印信息可以去掉,这里是给自己看的 
  system.out.println("this代表的是当前调用构造方法的对象" + this); 
 system.out.println("获取当前this对象的父类信息" + this.getclass().getsuperclass()); 
 system.out.println("获取当前this对象的父类信息(包括泛型信息)" + this.getclass().getgenericsuperclass()); 
 //拿到泛型的参数类型 
 parameterizedtype type = (parameterizedtype) this.getclass().getgenericsuperclass(); 
 clazz = (class)type.getactualtypearguments()[0]; 
 } 
 
 public void setsessionfactory(sessionfactory sessionfactory) { 
 this.sessionfactory = sessionfactory; 
 } 
 
 protected session getsession() { 
 //从当前线程获取session,如果没有则创建一个新的session 
 return sessionfactory.getcurrentsession(); 
 } 
 
 @override 
 public void save(t t) { 
 getsession().save(t); 
 } 
 
 @override 
 public void update(t t) { 
 getsession().update(t); 
 } 
 
 @override 
 public void delete(int id) { 
 system.out.println(clazz.getsimplename()); 
 string hql = "delete " + clazz.getsimplename() + " as c where c.id=:id"; 
 getsession().createquery(hql) // 
   .setinteger("id", id) // 
   .executeupdate(); 
 } 
 
 @override 
 public t get(int id) { 
 return (t) getsession().get(clazz, id); 
 } 
 
 @override 
 public list<t> query() { 
 string hql = "from " + clazz.getsimplename(); 
 return getsession().createquery(hql).list(); 
 } 
 
} 

抽取完了后,我们就可以改写categoryservice接口和categoryserviceimpl实现类了。如下:

//categoryservice接口继承baseservice接口 
public interface categoryservice extends baseservice<category> { 
 /* 
 * 只要添加categoryservice本身需要的新的方法即可,公共方法已经在baseservice中了 
 */ 
} 
 
/** 
 * @description todo(模块自身的业务逻辑) 
 * @author eson_15 
 * 
 */ 
public class categoryserviceimpl extends baseserviceimpl<category> implements categoryservice { 
 
 /* 
 * 只需实现categoryservice接口中新增的方法即可,公共方法已经在baseserviceimpl中实现了 
 */ 
} 

        从代码中可以看出,新增的service只需要继承baseservice接口,然后在接口中新增本service所需要的业务逻辑即可。新增的serviceimpl只需要继承baseserviceimpl并实现新增的业务逻辑即可。
        但是别忘了很重要的一点:就是修改spring的配置文件beans.xml中的bean

<!-- 泛型类是不能实例化的,所以要加lazy-init属性 --> 
<bean id="baseservice" class="cn.it.shop.service.impl.baseserviceimpl" lazy-init="true"> 
 <property name="sessionfactory" ref="sessionfactory" /> 
</bean> 
 
<bean id="categoryservice" class="cn.it.shop.service.impl.categoryserviceimpl" parent="baseservice"/> 

        将原来categoryservice中的property干掉,然后增加parent属性,指明继承baseservice;然后配置一下baseservice,将sessionfactory配到baseservice中去,另外要注意一点:设置lazy-init属性为true,因为baseservice是泛型类,泛型类是不能实例化的。至此,service层的抽取就搞定了。

2. service层添加一个account
        刚刚抽取好了service层,那么现在我们想写一个account(管理员)的service就很简单了:
        首先写一个accountservice接口继承baseservice:

public interface accountservice extends baseservice<account> { //注意baseservice里的泛型现在是account 
 /* 
 * 只要添加accountservice本身需要的新的方法即可,公共方法已经在baseservice中了 
 */ 
} 

        然后写一个accountserviceimpl实现类继承baseserviceimpl实现类,并实现accountservice接口即可:

public class accountserviceimpl extends baseserviceimpl<account> implements accountservice { 
 
 /* 
 * 只需实现accountservice接口中新增的方法即可,公共方法已经在baseserviceimpl中实现了 
 */ 
 
 //管理登陆功能,后期再完善 
} 

        最后在beans.xml文件里加上如下配置:
<bean id="accountservice" class="cn.it.shop.service.impl.accountserviceimpl" parent="baseservice" />  
        这样就写好了一个新的service了,以后需要添加service就遵循这个流程,非常方便。
3. action的抽取
3.1 action中往域(request,session,application等)中存数据
        我们知道,在action中可以直接通过actioncontext.getcontext()去获取一个actioncontext对象,然后通过该对象再去获得相应的域对象;也可以通过实现xxxaware接口来注入相应的域对象。我们先来看一下这两种方法:

public class categoryaction extends actionsupport implements requestaware,sessionaware,applicationaware{ 
 
 private category category; 
 
 private categoryservice categoryservice; 
 
 public void setcategoryservice(categoryservice categoryservice) { 
  this.categoryservice = categoryservice; 
 } 
 
 public string update() { 
 system.out.println("----update----"); 
 categoryservice.update(category); 
 return "index"; 
 } 
 
 public string save() { 
 system.out.println("----save----"); 
 return "index"; 
 } 
 
 public string query() { 
  //解决方案一,采用相应的map取代原来的内置对象,这样与jsp没有依赖,但是代码量比较大 
 // actioncontext.getcontext().put("categorylist", categoryservice.query()); //放到request域中 
 // actioncontext.getcontext().getsession().put("categorylist", categoryservice.query()); //放到session域中 
 // actioncontext.getcontext().getapplication().put("categorylist", categoryservice.query()); //放到application域中 
  
 //解决方案二,实现相应的接口(requestaware,sessionaware,applicationaware),让相应的map注入 
 request.put("categorylist", categoryservice.query()); 
 session.put("categorylist", categoryservice.query()); 
 application.put("categorylist", categoryservice.query()); 
 return "index"; 
 } 
 
 public category getcategory() { 
 return category; 
 } 
 
 public void setcategory(category category) { 
 this.category = category; 
 } 
 
 private map<string, object> request; 
 private map<string, object> session; 
 private map<string, object> application; 
 
 @override 
 public void setapplication(map<string, object> application) { 
 this.application = application; 
 } 
 
 @override 
 public void setsession(map<string, object> session) { 
 this.session = session; 
 } 
 
 @override 
 public void setrequest(map<string, object> request) { 
 this.request = request; 
 } 
} 

还是上一节整合三大框架时的categoryaction类,我们在里面加了一个query方法,在该方法中,我们通过向request域、session域和application域中存入查询的结果。第一种方法是直接使用actioncontext来实现,不需要实现任何接口,但是代码量较大;第二种方法通过实现requestaware、sessionaware和applicationaware接口,实现该接口的三个抽象方法把request、session和application注入进来,然后赋给相应的成员变量中,这样就可以在query方法中向域中存放查询结果了。这代码量貌似比第一种方法更大……但是我们可以抽取,先往下看。
我们在index.jsp中新加一个查询连接来测试能否将查询结果显示出来:

<%@ page language="java" import="java.util.*" pageencoding="utf-8"%> 
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 
<!doctype html public "-//w3c//dtd html 4.01 transitional//en"> 
<html> 
 <head> 
 <title>my jsp 'index.jsp' starting page</title> 
 </head> 
 
 <body> 
 <a href="${pagecontext.request.contextpath }/category_update.action?category.id=2&category.type=gga&category.hot=false">访问update</a> 
 <a href="category_save.action">访问save</a> 
 <a href="category_query.action">查询所有类别</a><br/> 
 <c:foreach items="${requestscope.categorylist }" var="category"> 
 ${category.id } | ${category.type } | ${category.hot } <br/> 
 </c:foreach> 
 
 <c:foreach items="${sessionscope.categorylist }" var="category"> 
 ${category.id } | ${category.type } | ${category.hot } <br/> 
 </c:foreach> 
 
 <c:foreach items="${applicationscope.categorylist }" var="category"> 
 ${category.id } | ${category.type } | ${category.hot } <br/> 
 </c:foreach> 
 </body> 
</html> 

3.2 抽取baseaction
        刚刚提到了,第二种方法的代码量更大,但是我们可以抽取一个baseaction,专门处理这些域相关的操作。

public class baseaction extends actionsupport implements requestaware,sessionaware,applicationaware { 
 
 protected map<string, object> request; 
 protected map<string, object> session; 
 protected map<string, object> application; 
 
 @override 
 public void setapplication(map<string, object> application) { 
 this.application = application; 
 } 
 
 @override 
 public void setsession(map<string, object> session) { 
 this.session = session; 
 } 
 
 @override 
 public void setrequest(map<string, object> request) { 
 this.request = request; 
 } 
} 

        然后我们自己的action如果需要用到这些域对象来存储数据时,直接继承baseaction即可,就能直接使用request、session和application对象了。所以修改后的categoryaction如下:

public class categoryaction extends baseaction { 
 
 private category category; 
<pre name="code" class="java"> 
 private categoryservice categoryservice; 
 
 public void setcategoryservice(categoryservice categoryservice) { 
  this.categoryservice = categoryservice; 
 } 
public string update() {system.out.println("----update----");categoryservice.update(category); return "index"; }public string save() {system.out.println("----save----");return "index"; } public string query() {request.put("categorylist", categoryservice.query()); session.put("categorylist", categoryservice.query()); application.put("categorylist", categoryservice.query()); return "index"; } public category getcategory() { return category; } public void setcategory(category category) {this.category = category; }}

        后面所有要使用request、session和application域的action,只要直接继承baseaction即可,非常方便。
3.3 获取参数(modeldriven)
        我们继续看上面的categoryaction类,里面有个成员变量category,这是个pojo,定义这个变量并写好set和get方法是为了jsp页面可以通过url后面附带参数传进来,参数是category对象中的属性,比如id,type等,但是url中的参数必须写成category.id、category.type等。这样struts会自动将这写参数注入到category对象中,然后我们就可以直接使用这个category对象了,但是这样有点繁琐。我们可以使用modeldriven来更方便的解决。

public class categoryaction extends baseaction implements modeldriven<category>{ 
 
 private category category; 
 
 //使用modeldriven接口必须要实现getmodel()方法,此方法会把返回的项压到栈顶 
 @override 
 public category getmodel() { 
 category = new category(); 
 return category; 
 } 
<pre name="code" class="java"> private categoryservice categoryservice; 
 
 public void setcategoryservice(categoryservice categoryservice) { 
  this.categoryservice = categoryservice; 
 } 
 
 public string update() { 
 system.out.println("----update----"); 
 categoryservice.update(category); 
 return "index"; 
 } 
 
 public string save() { 
 system.out.println("----save----"); 
 return "index"; 
 } 
 
 public string query() { 
 request.put("categorylist", categoryservice.query()); 
 session.put("categorylist", categoryservice.query()); 
 application.put("categorylist", categoryservice.query()); 
 return "index"; 
 } 
 
} 

这样我们在前台jsp页面就不用带category.id这种繁琐的参数了,看jsp页面中的modeldriven部分:

<%@ page language="java" import="java.util.*" pageencoding="utf-8"%> 
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 
<!doctype html public "-//w3c//dtd html 4.01 transitional//en"> 
<html> 
 <head> 
 <title>my jsp 'index.jsp' starting page</title> 
 </head> 
 
 <body> 
 <a href="${pagecontext.request.contextpath }/category_update.action?category.id=2&category.type=gga&category.hot=false">访问update</a> 
 <a href="category_save.action?id=1&type=haha&hot=true">测试modeldriven</a> 
 <a href="category_query.action">查询所有类别</a><br/> 
 <c:foreach items="${requestscope.categorylist }" var="category"> 
 ${category.id } | ${category.type } | ${category.hot } <br/> 
 </c:foreach> 
 
 <c:foreach items="${sessionscope.categorylist }" var="category"> 
 ${category.id } | ${category.type } | ${category.hot } <br/> 
 </c:foreach> 
 
 <c:foreach items="${applicationscope.categorylist }" var="category"> 
 ${category.id } | ${category.type } | ${category.hot } <br/> 
 </c:foreach> 
 </body> 
</html> 

        测试结果是可以获得catgory,并且将id,type和hot属性全部赋值好。我们可以看出,通过实现modeldriven接口,我们可以很方便的在url中携带参数,action中只需要实现getmodel方法,new一个要使用的对象返回即可。到这里我们很容易想到,struts中肯定会有很多这种model需要获取,所以这一块我们也要抽取到baseaction中去。
3.4 抽取modeldriven到baseaction
        首先我们在baseaction中添加modeldriven部分的代码,如下:

//因为有很多不同的model都需要使用modeldriven,所以这里使用泛型 
public class baseaction<t> extends actionsupport implements requestaware,sessionaware,applicationaware,modeldriven<t> { 
 
 protected map<string, object> request; 
 protected map<string, object> session; 
 protected map<string, object> application; 
 
 protected t model; 
 
 @override 
 public void setapplication(map<string, object> application) { 
 this.application = application; 
 } 
 
 @override 
 public void setsession(map<string, object> session) { 
 this.session = session; 
 } 
 
 @override 
 public void setrequest(map<string, object> request) { 
 this.request = request; 
 } 
 
 @override 
 public t getmodel() { //这里通过解析传进来的t来new一个对应的instance 
 parameterizedtype type = (parameterizedtype)this.getclass().getgenericsuperclass(); 
 class clazz = (class)type.getactualtypearguments()[0]; 
 try { 
  model = (t)clazz.newinstance(); 
 } catch (exception e) { 
  throw new runtimeexception(e); 
 } 
 return model; 
 } 
} 

抽取完了后,categoryaction中的代码会越来越少:

//继承baseaction,并且加上泛型 
public class categoryaction extends baseaction<category> { 
 
 private categoryservice categoryservice; 
 
 public void setcategoryservice(categoryservice categoryservice) { 
 this.categoryservice = categoryservice; 
 } 
 
 public string update() { 
 system.out.println("----update----"); 
 categoryservice.update(model);//直接使用model 
 return "index"; 
 } 
 
 public string save() { 
 system.out.println("----save----"); 
 system.out.println(model); //直接使用model 
 return "index"; 
 } 
 
 public string query() { 
 request.put("categorylist", categoryservice.query()); 
 session.put("categorylist", categoryservice.query()); 
 application.put("categorylist", categoryservice.query()); 
 return "index"; 
 } 
 
} 

        到这里,还有一个看着不爽的地方,就是categoryservice这个成员变量,它一直存在在categoryaction里,因为categoryaction中有用到categoryservice对象中的方法,所以必须得创建这个对象,并且有set方法才能注入进来。这就导致一个弊端:如果很多action都需要使用categoryservice的话,那就必须在它们的action里创建这个对象和set方法,而且,如果一个action中要使用好几个不同的service对象,那就得全部创建,这样就变得很冗杂。
3.5 抽取service到baseaction
        针对上面的问题,我们将工程中所有的service对象都抽取到baseaction中创建,这样其他action继承baseaction后,想用什么service就直接拿来用即可:

//我将baseaction中的内容归归类了 
public class baseaction<t> extends actionsupport implements requestaware,sessionaware,applicationaware,modeldriven<t> { 
 
 //service对象 
 protected categoryservice categoryservice; 
 protected accountservice accountservice; 
 
 public void setcategoryservice(categoryservice categoryservice) { 
 this.categoryservice = categoryservice; 
 } 
 public void setaccountservice(accountservice accountservice) { 
 this.accountservice = accountservice; 
 } 
 
 //域对象 
 protected map<string, object> request; 
 protected map<string, object> session; 
 protected map<string, object> application; 
  
 @override 
 public void setapplication(map<string, object> application) { 
 this.application = application; 
 } 
 @override 
 public void setsession(map<string, object> session) { 
 this.session = session; 
 } 
 @override 
 public void setrequest(map<string, object> request) { 
 this.request = request; 
 } 
 
 //modeldriven 
 protected t model; 
 @override 
 public t getmodel() { 
 parameterizedtype type = (parameterizedtype)this.getclass().getgenericsuperclass(); 
 class clazz = (class)type.getactualtypearguments()[0]; 
 try { 
  model = (t)clazz.newinstance(); 
 } catch (exception e) { 
  throw new runtimeexception(e); 
 } 
 return model; 
 } 
} 
 这样categoryaction中就更加清爽了:
public class categoryaction extends baseaction<category> { 
 
 public string update() { 
 system.out.println("----update----"); 
 categoryservice.update(model); 
 return "index"; 
 } 
 
 public string save() { 
 system.out.println("----save----"); 
 system.out.println(model); 
 return "index"; 
 } 
 
 public string query() { 
 request.put("categorylist", categoryservice.query()); 
 session.put("categorylist", categoryservice.query()); 
 application.put("categorylist", categoryservice.query()); 
 return "index"; 
 } 
 
} 

        有人可能会问,baseaction中注入了那么多service对象的话不会冗余么?这是不会的,因为就算不写在baseaction中,spring容器也是会创建这个对象的,这点没有关系,相反,service对象全放在baseaction中更加便于其他action的开发,而且baseaction不需要配到struts.xml文件中,因为根本就没有哪个jsp会请求baseaction,它只是让其他action来继承用的。
        还有一点别忘了:那就是修改在beans.xml中的配置:

<!-- 如果是prototype类型,默认是使用时创建,不是启动时自动创建 --> 
<bean id="baseaction" class="cn.it.shop.action.baseaction" scope="prototype"> 
 <property name="categoryservice" ref="categoryservice"></property> 
 <property name="accountservice" ref="accountservice"></property> 
</bean> 
 
<bean id="categoryaction" class="cn.it.shop.action.categoryaction" scope="prototype" parent="baseaction"/>

         新加一个baseaction的bean,将工程中所有service对象作为property配好,将原来的categoryaction中的property干掉。
        以后我们如果要写新的xxxaction,直接继承baseaction即可,如果xxxaction中有用到某个service,直接拿来用即可,只需要在beans.xml文件中加一个xxxaction对应的bean,在struts.xml文件中配置好跳转即可。

4. 将xml改成注解
        我们可以看到,随着项目越写越大,beans.xml中的配置会越来越多,而且很多配置有冗余,为了更加便于开发,我们现在将xml的配置改成注解的形式,我们先看一下beans.xml中的配置:

        这些是我们之前搭建环境以及抽取的时候写的bean,这些都需要转换成注解的形式,下面我们一块一块的换掉:首先替换service部分,这部分有三个:baseservice、categoryservice和accountservice。替换如下:

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

        然后将beans.xml中的相应部分干掉即可。接下来修改action部分,主要有baseaction、categoryaction和accountaction三个,替换如下:

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

        然后再干掉beans.xml中的action部分的配置即可,最后在beans.xml文件中添加一个如下配置,就可以使用注解了。
<context:component-scan base-package="cn.it.shop.."/> 
        有人可能会问,为什么service和action两个使用注解的时候不一样呢?service中使用的是@service而action中使用的是@controller呢?其实是一样的,只是为了区分它们是不同层的bean而已,便于阅读。

整个项目的源码下载地址:

原文地址:

以上就是ssh框架网上商城项目第2战的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。