程序博客网 > python 遍历字符串

ssh开发实现积分商城层1.3

来源：互联网 发布：python 遍历字符串 编辑：程序博客网 时间：2024/04/28 14:25

11.3  实现积分商城层

11.3.1  概述

       积分商城是基于通用层之上进行开发，这样我们能减少很多重复的劳动，加快项目开发进度。

11.3.2 实现数据模型层

1、商品表，定义了如商品名称、简介、原需积分、现需积分等，其中是否发布表示只有发布（true）了的商品才会在前台删除，是否已删除表示不会物理删除，商品不应该物理删除，而是逻辑删除，版本属性用于防止并发更新。

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.model;  
  2. /** 商品表 */  
  3. @Entity  
  4. @Table(name = "tb_goods")  
  5. public class GoodsModel implements java.io.Serializable {  
  6.      /** 主键 */  
  7.     @Id @GeneratedValue(strategy = GenerationType.IDENTITY)  
  8.     @Column(name = "id", length = 10)  
  9.     private int id;  
  10.     /** 商品名称 */  
  11.     @Column(name = "name", nullable = false, length = 100)  
  12.     private String name;  
  13.     /** 商品简介 */  
  14.     @Column(name = "description", nullable = false, length = 100)  
  15.     private String description;  
  16.     /** 原需积分 */  
  17.     @Column(name = "original_point", nullable = false, length = 10)  
  18.     private int originalPoint;  
  19.     /** 现需积分 */  
  20.     @Column(name = "now_point", nullable = false, length = 10)  
  21.     private int nowPoint;  
  22.     /** 是否发布，只有发布的在前台显示 */  
  23.     @Column(name = "published", nullable = false)  
  24.     private boolean published;  
  25.     /** 是否删除，商品不会被物理删除的 */  
  26.     @Column(name = "is_delete", nullable = false)  
  27.     private boolean deleted;  
  28.     /** 版本 */  
  29.     @Version  @Column(name = "version", nullable = false, length = 10)  
  30.     private int version;  
  31.     //省略getter和setter、hashCode及equals，实现请参考源代码  
  32. }  

 

 

2、商品兑换码表，定义了兑换码、兑换码所属商品（兑换码和商品直接是多对一关系）、购买人、购买时间、是否已经购买（防止一个兑换码多个用户兑换）、版本。

 

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.model;  
  2. import java.util.Date;  
  3. //省略部分import  
  4. /** 商品兑换码表 */  
  5. @Entity  
  6. @Table(name = "tb_goods_code")  
  7. public class GoodsCodeModel implements java.io.Serializable {  
  8.      /** 主键 */  
  9.     @Id @GeneratedValue(strategy = GenerationType.IDENTITY)  
  10.     @Column(name = "id", length = 10)  
  11.     private int id;  
  12.     /** 所属商品 */  
  13.     @ManyToOne  
  14.     private GoodsModel goods;  
  15.     /** 兑换码*/  
  16.     @Column(name = "code", nullable = false, length = 100)  
  17.     private String code;  
  18.     /** 兑换人,实际环境中应该和用户表进行对应*/  
  19.     @Column(name = "username", nullable = true, length = 100)  
  20.     private String username;  
  21.     
  22.     /** 兑换时间*/  
  23.     @Column(name = "exchange_time")  
  24.     private Date exchangeTime;  
  25.     /** 是否已经兑换*/  
  26.     @Column(name = "exchanged")  
  27.     private boolean exchanged = false;  
  28.     /** 版本 */  
  29.     @Version  
  30.     @Column(name = "version", nullable = false, length = 10)  
  31.     private int version;  
  32.     //省略getter和setter、hashCode及equals，实现请参考源代码  
  33. }  

 

 

 

3、商品表及商品兑换码表之间关系，即一个商品有多个兑换码，如图11-10所示：

 

图11-10商品表及商品兑换码表之间关系

4、 创建数据库及表结构的SQL语句文件（sql/ pointShop_schema.sql）：

 

java代码：
Java代码  收藏代码
  1. CREATE DATABASE IF NOT EXISTS `point_shop`   
  2. DEFAULT CHARACTER SET 'utf8';  
  3. USE `point_shop`;  
  4. DROP TABLE IF EXISTS `tb_goods_code`;  
  5. DROP TABLE IF EXISTS `tb_goods`;  
  6. -- ----------------------------  
  7. -- Table structure for 商品表  
  8. -- ----------------------------  
  9. CREATE TABLE `tb_goods` (  
  10.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '商品id',  
  11.   `name` varchar(100) NOT NULL COMMENT '商品名称',  
  12.   `description` varchar(100) NOT NULL COMMENT '商品简介',  
  13.   
  14.   `original_point` int(10) unsigned NOT NULL  COMMENT '原需积分',  
  15.   `now_point` int(10) unsigned NOT NULL  COMMENT '现需积分',  
  16.   `published` bool NOT NULL  COMMENT '是否发布',  
  17.   `is_delete` bool NOT NULL DEFAULT false COMMENT '是否删除',  
  18.   `version` int(10) unsigned NOT NULL DEFAULT 0 COMMENT '版本',  
  19.    PRIMARY KEY (`id`),  
  20.    INDEX(`name`),  
  21.    INDEX(`published`)  
  22.   )ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='商品表';  
  23. -- ----------------------------  
  24. -- Table structure for 商品兑换码表  
  25. -- ----------------------------  
  26. CREATE TABLE `tb_goods_code` (  
  27.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键id',  
  28.   `username` varchar(100) COMMENT '兑换用户',  
  29.   `goods_id` int(10) unsigned NOT NULL COMMENT '所属商品id',  
  30.   `code` varchar(100)  NOT NULL COMMENT '积分',  
  31.   `exchange_time` datetime  COMMENT '购买时间',  
  32.   `exchanged` bool DEFAULT false COMMENT '是否已经兑换',  
  33.   `version` int(10) unsigned NOT NULL DEFAULT 0 COMMENT '版本',  
  34.    PRIMARY KEY (`id`),  
  35.    FOREIGN KEY (`goods_id`) REFERENCES `tb_goods` (`id`)  ON DELETE CASCADE  
  36.   )ENGINE=InnoDB AUTO_INCREMENT=1000000 DEFAULT CHARSET=utf8 COMMENT='商品兑换码表';  
  37.    

              Mysql数据库引擎应该使用InnoDB，如果使用MyISM将不支持事务。

 

 

11.3.3  实现数据访问层

数据访问层只涉及与底层数据库或文件系统等打交道，不会涉及业务逻辑，一定注意层次边界，不要在数据访问层实现业务逻辑。

 

商品模块的应该实现如下功能：

  • 继承通用数据访问层的CRUD功能；
  • 分页查询所有已发布的商品
  • 统计所有已发布的商品；

 

商品兑换码模块的应该实现如下功能：

  • 继承通用数据访问层的CRUD功能；
  • 根据商品ID分页查询该商品的兑换码
  • 根据商品ID统计该商品的兑换码记录数；
  • 根据商品ID获取一个还没有兑换的商品兑换码

 

1、商品及商品兑换码DAO接口定义：

 

商品及商品兑换码DAO接口定义直接继承IBaseDao，无需在这些接口中定义重复的CRUD方法了，并通过泛型指定数据模型类及主键类型。

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.dao;  
  2. //省略import  
  3. /** 商品模型对象的DAO接口 */  
  4. public interface IGoodsDao extends IBaseDao<GoodsModel, Integer> {  
  5.     /** 分页查询所有已发布的商品*/  
  6.     List<GoodsModel> listAllPublished(int pn);  
  7.     /** 统计所有已发布的商品记录数*/  
  8.     int countAllPublished();  
  9. }  

 

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.dao;  
  2. //省略import  
  3. /** 商品兑换码模型对象的DAO接口 */  
  4. public interface IGoodsCodeDao extends IBaseDao<GoodsCodeModel, Integer> {  
  5.     /** 根据商品ID统计该商品的兑换码记录数*/  
  6.     public int countAllByGoods(int goodsId);  
  7.     /** 根据商品ID查询该商品的兑换码列表*/  
  8.     public List<GoodsCodeModel> listAllByGoods(int pn, int goodsId);  
  9.     /** 根据商品ID获取一个还没有兑换的商品兑换码 */  
  10.     public GoodsCodeModel getOneNotExchanged(int goodsId);  
  11. }  

 

 

2、 商品及商品兑换码DAO接口实现定义：

 

DAO接口实现定义都非常简单，对于CRUD实现直接从BaseHibernateDao继承即可，无需再定义重复的CRUD实现了，并通过泛型指定数据模型类及主键类型。

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.dao.hibernate;  
  2. //省略import  
  3. public class GoodsHibernateDao extends BaseHibernateDao<GoodsModel, Integer> implements IGoodsDao {  
  4.     @Override  //覆盖掉父类的delete方法，不进行物理删除  
  5.     public void delete(Integer id) {  
  6.         GoodsModel goods = get(id);  
  7.         goods.setDeleted(true);  
  8.         update(goods);  
  9.     }  
  10.     @Override //覆盖掉父类的getCountAllHql方法，查询不包括逻辑删除的记录  
  11.     protected String getCountAllHql() {  
  12.         return super.getCountAllHql() + " where deleted=false";  
  13.     }  
  14.     @Override //覆盖掉父类的getListAllHql方法，查询不包括逻辑删除的记录  
  15.     protected String getListAllHql() {  
  16.         return super.getListAllHql() + " where deleted=false";  
  17.     }  
  18.     @Override //统计没有被逻辑删除的且发布的商品数量  
  19.     public int countAllPublished() {  
  20.         String hql = getCountAllHql() + " and published=true";  
  21.         Number result = unique(hql);  
  22.             return result.intValue();  
  23.     }  
  24.     @Override //查询没有被逻辑删除的且发布的商品  
  25.     public List<GoodsModel> listAllPublished(int pn) {  
  26.         String hql = getListAllHql() + " and published=true";  
  27.         return list(hql, pn, Constants.DEFAULT_PAGE_SIZE);  
  28.     }  
  29. }  
  30.    

 

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.dao.hibernate;  
  2. //省略import  
  3. public class GoodsCodeHibernateDao extends   
  4. BaseHibernateDao<GoodsCodeModel, Integer> implements IGoodsCodeDao {  
  5. @Override  //根据商品ID查询该商品的兑换码  
  6.     public List<GoodsCodeModel> listAllByGoods(int pn, int goodsId) {  
  7.         final String hql = getListAllHql() + " where goods.id = ?";  
  8.         return list(hql, pn, Constants.DEFAULT_PAGE_SIZE , goodsId);  
  9.     }  
  10. @Override //根据商品ID统计该商品的兑换码数量  
  11.     public int countAllByGoods(int goodsId) {  
  12.         final String hql = getCountAllHql() + " where goods.id = ?";  
  13.         Number result = unique(hql, goodsId);  
  14.         return result.intValue();  
  15.     }  
  16.    

 

            

 

3、Spring DAO层配置文件（resources/cn/javass/point/dao/ applicationContext-hibernate.xml）：

  DAO配置文件中定义Hibernate的SessionFactory、事务管理器和DAO实现。

 

java代码：
Java代码  收藏代码
  1. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
  2.     <property name="dataSource" ref="dataSource"/><!-- 1、指定数据源 -->  
  3.     <property name="annotatedClasses">           <!-- 2、指定注解类 -->  
  4.         <list>  
  5.              <value>cn.javass.point.model.GoodsModel</value>  
  6.              <value>cn.javass.point.model.GoodsCodeModel</value>  
  7.         </list>  
  8.     </property>  
  9.     <property name="hibernateProperties"><!-- 3、指定Hibernate属性 -->  
  10.        <props>  
  11.            <prop key="hibernate.dialect">${hibernate.dialect}</prop>  
  12.            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
  13.            <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>  
  14.            <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>  
  15.         </props>  
  16.     </property>  
  17. </bean>  
  18. <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">    
  19.       <property name="sessionFactory" ref="sessionFactory"/>  
  20. </bean>  

 

 

 

java代码：
Java代码  收藏代码
  1. <bean id="abstractDao" abstract="true" init-method="init">  
  2.     <property name="sessionFactory" ref="sessionFactory"/>  
  3. </bean>     
  4. <bean id="goodsDao" class="cn.javass.point.dao.hibernate.GoodsHibernateDao" parent="abstractDao"/>  
  5. <bean id="goodsCodeDao" class="cn.javass.point.dao.hibernate.GoodsCodeHibernateDao" parent="abstractDao"/>  
  6.    

 

 

4、修改替换配置元数据的资源文件（resources/resources.properties），添加Hibernate属性相关：

 

java代码：
Java代码  收藏代码
  1.       
  2. #Hibernate属性  
  3. hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect  
  4. hibernate.hbm2ddl.auto=none  
  5. hibernate.show_sql=false  
  6. hibernate.format_sql=true  

 

 

11.3.4 实现业务逻辑层

业务逻辑层实现业务逻辑，即系统中最复杂、最核心的功能，不应该在业务逻辑层出现如数据库访问等底层代码，对于这些操作应委托给数据访问层实现，从而保证业务逻辑层的独立性和可复用性，并应该在业务逻辑层组装分页对象。

 

 

商品模块应该实现如下功能：

  • CURD操作，直接委托给通用业务逻辑层；
  • 根据页码查询所有已发布的商品的分页对象，即查询指定页的记录，这是和数据访问层不同的；

 

商品兑换码模块应该实现如下功能：

  • CURD操作，直接委托给通用业务逻辑层；
  • 根据页码和商品Id查询查询所有商品兑换码分页对象，即查询指定页的记录；
  • 新增指定商品的兑换码，用于对指定商品添加兑换码；
  • 购买指定商品兑换码操作，用户根据商品购买该商品的兑换码，如果指定商品的兑换码没有了将抛出没有兑换码异常NotCodeException；

 

1、商品及商品兑换码Service接口定义：

 

接口定义时，对于CRUD直接继承IBaseService即可，无需再在这些接口中定义重复的CRUD方法了，并通过泛型指定数据模型类及数据模型的主键。

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.service;  
  2. //省略import  
  3. public interface IGoodsService extends IBaseService<GoodsModel, Integer> {  
  4.     /**根据页码查询所有已发布的商品的分页对象*/  
  5.     Page<GoodsModel> listAllPublished(int pn);  
  6. }  

 

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.service;  
  2. //省略import  
  3. public interface IGoodsCodeService extends IBaseService<GoodsCodeModel, Integer> {  
  4.     /** 根据页码和商品Id查询查询所有商品兑换码分页对象*/  
  5.     public Page<GoodsCodeModel> listAllByGoods(int pn, int goodsId);  
  6.     /** 新增指定商品的兑换码*/  
  7.     public void save(int goodsId, String[] codes);  
  8.     /** 购买指定商品兑换码 */  
  9.     GoodsCodeModel buy(String username, int goodsId) throws NotCodeException ;  
  10. }  

 

2、NotCodeException异常定义，表示指定商品的兑换码已经全部被兑换了，没有剩余的兑换码了：

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.exception;  
  2. /** 购买失败异常,表示没有足够的兑换码 */  
  3. public class NotCodeException extends RuntimeException {  
  4. }  

    NotCodeException异常类实现RuntimeException，当需要更多信息时可以在异常中定义，异常比硬编码错误代码（如-1表示没有足够的兑换码）更好理解。

 

 

3、商品及商品兑换码Service接口实现定义：

 

接口实现时，CRUD实现直接从BaseServcice继承即可，无需再在这些专有实现中定义重复的CRUD实现了，并通过泛型指定数据模型类及数据模型的主键。

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.service.impl;  
  2. //省略import  
  3. public class GoodsServiceImpl extends BaseServiceImpl<GoodsModel, Integer> implements IGoodsService {  
  4.     @Override  
  5.     public Page<GoodsModel> listAllPublished(int pn) {  
  6.         int count = getGoodsDao().countAllPublished();  
  7.         List<GoodsModel> items = getGoodsDao().listAllPublished(pn);  
  8.         return PageUtil.getPage(count, pn, items, Constants.DEFAULT_PAGE_SIZE);  
  9.     }  
  10.     IGoodsDao getGoodsDao() {//将通用DAO转型  
  11.         return (IGoodsDao) getDao();  
  12.     }  
  13. }  
  14.    

 

 

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.service.impl;  
  2. //省略import  
  3. public class GoodsCodeServiceImpl extends BaseServiceImpl<GoodsCodeModel, Integer> implements IGoodsCodeService {  
  4.     private IGoodsService goodsService;  
  5.     public void setGoodsService(IGoodsService goodsService) {//注入IGoodsService  
  6.         this.goodsService = goodsService;  
  7.     }  
  8.     private IGoodsCodeDao getGoodsCodeDao() {//将注入的通用DAO转型  
  9.         return (IGoodsCodeDao) getDao();  
  10.     }  
  11.     @Override  
  12.     public Page<GoodsCodeModel> listAllByGoods(int pn, int goodsId) {  
  13.         Integer count = getGoodsCodeDao().countAllByGoods(goodsId);  
  14.         List<GoodsCodeModel> items = getGoodsCodeDao().listAllByGoods(pn, goodsId);  
  15.         return PageUtil.getPage(count, pn, items, Constants.DEFAULT_PAGE_SIZE);  
  16.     }  
  17.     @Override  
  18.     public void save(int goodsId, String[] codes) {  
  19.         GoodsModel goods = goodsService.get(goodsId);  
  20.         for(String code : codes) {  
  21.             if(StringUtils.hasText(code)) {  
  22.                 GoodsCodeModel goodsCode = new GoodsCodeModel();  
  23.                 goodsCode.setCode(code);  
  24.                 goodsCode.setGoods(goods);  
  25.             save(goodsCode);  
  26.             }  
  27.         }  
  28.     }  
  29.     @Override  
  30.     public GoodsCodeModel buy(String username, int goodsId)  throws NotCodeException {  
  31.         //1、实际实现时要验证用户积分是否充足  
  32.         //2、其他逻辑判断  
  33.         //3、实际实现时要记录交易记录开始      
  34.        GoodsCodeModel goodsCode = getGoodsCodeDao().getOneNotExchanged(goodsId);  
  35.   
  36.        if(goodsCode == null) {  
  37.             //3、实际实现时要记录交易记录失败  
  38.             throw new NotCodeException();  
  39.             //目前只抛出一个异常，还可能比如并发购买情况  
  40.        }  
  41.        goodsCode.setExchanged(true);  
  42.        goodsCode.setExchangeTime(new Date());  
  43.        goodsCode.setUsername(username);  
  44.        save(goodsCode);  
  45.        //3、实际实现时要记录交易记录成功  
  46.        return goodsCode;  
  47.     }  
  48. }  

    save方法和buy方法实现并不是最优的，save方法中如果兑换码有上千个怎么办？这时就需要批处理了，通过批处理比如20条一提交数据库来提高性能。buy方法就要考虑多个用户同时购买同一个兑换码如何处理？

 

交易历史一定要记录，从交易开始到交易结束（不管成功与否）一定要记录用于当客户投诉时查询相应数据。

 

 

4、Spring Service层配置文件（resources/cn/javass/point/service/ applicationContext-service.xml）：

 

Service层配置文件定义了事务和Service实现。

 

java代码：
Java代码  收藏代码
  1. <tx:advice id="txAdvice" transaction-manager="txManager">  
  2. <tx:attributes>  
  3. <tx:method name="save*" propagation="REQUIRED" />  
  4.         <tx:method name="add*" propagation="REQUIRED" />  
  5.         <tx:method name="create*" propagation="REQUIRED" />  
  6.         <tx:method name="insert*" propagation="REQUIRED" />  
  7.         <tx:method name="update*" propagation="REQUIRED" />  
  8.         <tx:method name="del*" propagation="REQUIRED" />  
  9.         <tx:method name="remove*" propagation="REQUIRED" />  
  10.         <tx:method name="buy*" propagation="REQUIRED" />  
  11.         <tx:method name="count*" propagation="SUPPORTS" read-only="true" />  
  12.         <tx:method name="find*" propagation="SUPPORTS" read-only="true" />  
  13.         <tx:method name="list*" propagation="SUPPORTS" read-only="true" />  
  14.         <tx:method name="*" propagation="SUPPORTS" read-only="true" />  
  15.     </tx:attributes>  
  16. </tx:advice>  
  17.    

 

 

java代码：
Java代码  收藏代码
  1. <aop:config>  
  2.     <aop:pointcut id="txPointcut" expression="execution(* cn.javass.point.service.*.*(..))" />  
  3.     <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />  
  4. </aop:config>  
  5. <bean id="goodsService" class="cn.javass.point.service.impl.GoodsServiceImpl">  
  6.     <property name="dao" ref="goodsDao"/>  
  7. </bean>  
  8. <bean id="goodsCodeService" class="cn.javass.point.service.impl.GoodsCodeServiceImpl">  
  9.     <property name="dao" ref="goodsCodeDao"/>  
  10.     <property name="goodsService" ref="goodsService"/>  
  11. </bean>  
  12.    
  13.    

 

11.3.5 实现表现层

表现层显示页面展示和交互，应该支持多种视图技术（如JSP、Velocity），表现层实现不应该实现诸如业务逻辑层功能，只负责调用业务逻辑层查找数据模型并委托给相应的视图进行展示数据模型。

 

积分商城分为前台和后台，前台负责与客户进行交互，如购买商品；后台是负责商品及商品兑换码维护的，只应该管理员有权限操作。

 

后台模块：

  • 商品管理模块：负责商品的维护，包括列表、新增、修改、删除、查询所有商品兑换码功能；
  • 商品兑换码管理模块：包括列表、新增、删除所有兑换码操作；

前台模块：只有已发布商品展示，用户购买指定商品时，如果购买成功则给用户发送兑换码，购买失败给用户错误提示。

 

 

表现层Action实现时一般使用如下规约编程：

  • Action方法定义：使用如list方法表示展示列表，doAdd方法表示去新增页面，add方法表示提交新增页面的结果并委托给Service层进行处理；
  • 结果定义：如使用“list”结果表示到展示列表页面，“add”结果去新增页面等等；
  • 参数设置：一般使用如“model”表示数据模型，使用“page”表示分页对象。

 

1、集成Struts2和Spring配置：

1.1、Spring Action配置文件：即Action将从Spring容器中获取，前台和后台配置文件应该分开以便好管理；

  • 后台Action配置文件resources/cn/javass/web/pointShop-admin-servlet.xml；
  • 前台Action配置文件resources/cn/javass/web/pointShop-front-servlet.xml；

1.2、Struts配置文件定义（resources/struts.xml）:

  为了提高开发效率和采用规约编程，我们将使用模式匹配通配符来定义action。对于管理后台和前台应该分开，URL模式将类似于/{module}/{action}/{method}.action：

  • module即模块名如admin，action即action前缀名，如后台的“GoodsAction”可以使用“goods”，method即Action中的方法名如“list”。
  • 可以在Struts配置文件中使用{1}访问第一个通配符匹配的结果，以此类推；
  • Reuslt也采用规约编程，即只有符合规律的放置jsp文件才会匹配到，如Result为“/WEB-INF/jsp/admin/{1}/list.jsp”，而URL为/goods/list.action 结果将为“/WEB-INF/jsp/admin/goods/list.jsp”。

 

java代码：
Java代码  收藏代码
  1. <package name="admin" extends="custom-default" namespace="/admin">  
  2.         <action name="*/*" class="/admin/{1}Action" method="{2}">  
  3.            <result name="redirect" type="redirect">/admin/{1}/list.action</result>  
  4.            <result name="list">/WEB-INF/jsp/admin/{1}/list.jsp</result>  
  5.            <result name="add">/WEB-INF/jsp/admin/{1}/add.jsp</result>  
  6.         </action>  
  7.     </package>  

  在此我们继承了“custom-default”包来支持action名字中允许“/”。

 

 如“/admin/goods/list.action”将调用cn.javass.point.web.admin.action.GoodsAction的list方法。

 

java代码：
Java代码  收藏代码
  1. <package name="front" extends="custom-default">  
  2.         <action name="*/*" class="/front/{1}Action" method="{2}">  
  3.            <result name="redirect" type="redirect">/{1}/list.action</result>  
  4.            <result name="list">/WEB-INF/jsp/front/{1}/list.jsp</result>  
  5.            <result name="add">/WEB-INF/jsp/front/{1}/add.jsp</result>  
  6.            <result name="buyResult">/WEB-INF/jsp/front/{1}/buyResult.jsp</result>  
  7.         </action>  
  8.     </package>  

  如“/goods/list.action”将调用cn.javass.point.web.front.action.GoodsAction的list方法。

 

 

1.3、web.xml配置：将Spring配置文件加上；

 

java代码：
Java代码  收藏代码
  1. <context-param>  
  2.     <param-name>contextConfigLocation</param-name>  
  3.     <param-value>  
  4.         classpath:applicationContext-resources.xml,  
  5.         classpath:cn/javass/point/dao/applicationContext-hibernate.xml,  
  6.         classpath:cn/javass/point/service/applicationContext-service.xml,  
  7.         classpath:cn/javass/point/web/pointShop-admin-servlet.xml,  
  8.         classpath:cn/javass/point/web/pointShop-front-servlet.xml  
  9.     </param-value>  
  10. </context-param>  

 

 

 

2、后台商品管理模块

 

商品管理模块实现商品的CRUD，本示例只演示新增，删除和更新由于篇幅问题留作练习。

 

2.1、Action实现

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.web.admin.action;  
  2. //省略import  
  3. public class GoodsAction extends BaseAction {  
  4.     public String list() {//列表、展示所有商品（包括未发布的）  
  5.         getValueStack().set(PAGE, goodsService.listAll(getPn()));  
  6.         return LIST;  
  7.     }  
  8.     public String doAdd() {//到新增页面  
  9.         goods = new GoodsModel();  
  10.         getValueStack().set(MODEL, goods);  
  11.         return ADD;  
  12.     }  
  13.     public String add() {//保存新增模型对象  
  14.         goodsService.save(goods);  
  15.         return REDIRECT;  
  16.     }  
  17.     //字段驱动数据填充  
  18.     private int id = -1;   //前台提交的商品ID  
  19.     private GoodsModel goods; //前台提交的商品模型对象  
  20.     //省略字段驱动数据的getter和setter  
  21.     //依赖注入Service  
  22.     private IGoodsService goodsService;  
  23.     //省略依赖注入的getter和setter  
  24. }  

 

2.2、Spring配置文件定义（resources/cn/javass/web/pointShop-admin-servlet.xml）：

 

java代码：
Java代码  收藏代码
  1. <bean name="/admin/goodsAction" class="cn.javass.point.web.admin.action.GoodsAction" scope="prototype">  
  2.     <property name="goodsService" ref="goodsService"/>  
  3. </bean>  

 

2.3、JSP实现商品列表页面（WEB-INF/jsp/admin/goods/list.jsp）

 

查询所有商品，通过迭代“page.items”（Page对象的items属性中存放着分页列表数据）来显示商品列表，在最后应该有分页标签（请参考源代码，示例无），如类似于“<my:page url="${ctx}/admin/goods/list.action"/>”来定义分页元素。

 


java代码：
Java代码  收藏代码
  1. <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
  2. <%@ include file="../../common/inc/tld.jsp"%>  
  3. <jsp:include page="../../common/inc/header.jsp">  
  4.     <jsp:param name="title" value="商品管理-商品列表"/>  
  5. </jsp:include>  
  6. <a href="${ctx}/admin/goods/doAdd.action">新增</a><br/>  
  7. <table border="1">  
  8.     <tr>  
  9.         <th>ID</th>  
  10.         <th>商品名称</th>  
  11.         <th>商品描述</th>  
  12.         <th>原需积分</th>  
  13.         <th>现需积分</th>  
  14.         <th>是否已发布</th>  
  15.         <th></th>  
  16.         <th></th>  
  17.         <th></th>  
  18. </tr>  
  19.   <s:iterator value="page.items">  
  20. <tr>  
  21.         <td><a href="${ctx}/admin/goods/toUpdate.action?id=<s:property value='id'/>"><s:property value="id"/></a></td>  
  22.         <td><s:property value="name"/></td>  
  23.         <td><s:property value="description"/></td>  
  24.         <td><s:property value="originalPoint"/></td>  
  25.         <td><s:property value="nowPoint"/></td>  
  26.         <td><s:property value="published"/></td>  
  27.         <td>更新</td> <td>删除</td>  
  28.         <td><a href="${ctx}/admin/goodsCode/list.action?goodsId=<s:property value='id'/>">查看Code码</a></td>  
  29.     </tr>     
  30.     </s:iterator>  
  31. </table>  
  32. <jsp:include page="../../common/inc/footer.jsp"/>  

 


 

右击“pointShop”项目选择【Run As】>【Run On Server】启动Tomcat服务器，在浏览器中输入“http://localhost:8080/pointShop/admin/goods/list.action”将显示图11-11界面。

 

图11-11 后台商品列表页面

2.4、JSP实现商品新增页面（WEB-INF/jsp/admin/goods/add.jsp）

表单提交到/admin/goods/add.action即cn.javass.point.web.admin.action.GoodsAction的add方法。并将参数绑定到goods属性上，在此我们没有进行数据验证，在实际项目中页面中和Action中都要进行数据验证。

 

java代码：
Java代码  收藏代码
  1. <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>  
  2. <%@ include file="../../common/inc/tld.jsp"%>  
  3. <jsp:include page="../../common/inc/header.jsp">  
  4.     <jsp:param name="title" value="商品管理-新增"/>  
  5. </jsp:include>  
  6. <s:fielderror cssStyle="color:red"/>  
  7. <s:form action="/admin/goods/add.action" method="POST" acceptcharset="UTF-8" >  
  8. <s:token/>  
  9. <table border="1">  
  10.     <s:hidden name="goods.id" value="%{model.id}"/>  
  11.     <s:hidden name="goods.version" value="%{model.version}"/>  
  12.     <tr>  
  13.         <s:textfield label="商品名称" name="goods.name" value="%{model.name}" required="true"/>  
  14.     </tr>  
  15.   
  16.     <tr>  
  17.         <s:textarea label="商品简介" name="goods.description" value="%{model.description}" required="true" cols="20" rows="3"/>  
  18.     </tr>  
  19.     <tr>  
  20.         <s:textfield label="原需积分" name="goods.originalPoint" value="%{model.originalPoint}" required="true"/>  
  21.     </tr>  
  22.     <tr>  
  23.         <s:textfield label="现需积分" name="goods.nowPoint" value="%{model.nowPoint}" required="true"/>  
  24.     </tr>  
  25.     <tr>  
  26.         <s:radio label="是否发布" name="goods.published" list="#{true:'发布',false:'不发布'}" value="%{model.published}" />  
  27.     </tr>  
  28.     <tr>  
  29.        <td><input name="submit" type="submit" value="新增"/></td>  
  30.     <td>  
  31.         <input name="cancel" type="button" onclick="javascript:window.location.href='${ctx}/admin/goods/list.action'" value="取消"/>  
  32.     </td>  
  33.     </tr>     
  34. </table>  
  35. </s:form>  
  36. <jsp:include page="../../common/inc/footer.jsp"/>  

 


 

右击“pointShop”选择【Run As】>【Run On Server】启动Tomcat服务器，在商品列表页面单间【新增】按钮将显示图11-11界面。

 

图11-12 后台商品新增页面

 

3、后台兑换码管理

 

提供根据商品ID查询兑换码列表及新增兑换码操作，兑换码通过文本框输入多个，使用换行分割。

 

3.1、Action实现

 

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.web.admin.action;  
  2. //省略import  
  3. public class GoodsCodeAction extends BaseAction {  
  4.     public String list() {  
  5.         getValueStack().set(MODEL, goodsService.get(goodsId));  
  6.         getValueStack().set(PAGE,  
  7.        goodsCodeService.listAllByGoods(getPn(), goodsId));  
  8.         return LIST;  
  9.     }  
  10.     public String doAdd() {  
  11.         getValueStack().set(MODEL, goodsService.get(goodsId));  
  12.         return ADD;  
  13.     }  
  14.     public String add() {  
  15.         String[] codes = splitCodes();  
  16.         goodsCodeService.save(goodsId, codes);  
  17.         return list();  
  18.     }  
  19.     private String[] splitCodes() {//将根据换行分割code码  
  20.         if(codes == null) {  
  21.             return new String[0];  
  22.         }  
  23.         return codes.split("\r"); //简单起见不考虑“\n”  
  24.     }     
  25.     //字段驱动数据填充  
  26.     private int id = -1;      //前台提交的商品兑换码ID  
  27.     private int goodsId = -1; //前台提交的商品ID  
  28.     private String codes;//前台提交的兑换码，由换行分割  
  29.     private GoodsCodeModel goodsCode; //前台提交的商品兑换码模型对象  
  30.     //省略字段驱动数据的getter和setter  
  31.     //依赖注入Service  
  32.     private IGoodsCodeService goodsCodeService;  
  33.     private IGoodsService goodsService;  
  34.     //省略依赖注入的getter和setter  
  35. }  

 

 

3.2、Spring配置文件定义（resources/cn/javass/web/pointShop-admin-servlet.xml）：

 

java代码：
Java代码  收藏代码
  1. <bean name="/admin/goodsCodeAction"  
  2. class="cn.javass.point.web.admin.action.GoodsCodeAction" scope="prototype">  
  3. <property name="goodsService" ref="goodsService"/>  
  4.     <property name="goodsCodeService" ref="goodsCodeService"/>  
  5. </bean>  

 

 

3.3、JSP实现商品兑换码列表页面（WEB-INF/jsp/admin/goodsCode/list.jsp）

 

商品兑换码列表页面时将展示相应商品的兑换码。

 

java代码：
Java代码  收藏代码
  1. <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
  2. <%@ include file="../../common/inc/tld.jsp"%>  
  3. <jsp:include page="../../common/inc/header.jsp">  
  4.     <jsp:param name="title" value="商品管理-商品Code码列表"/>  
  5. </jsp:include>  
  6. <a href="${ctx}/admin/goodsCode/doAdd.action?goodsId=${model.id}">新增</a>|  
  7. <a href="${ctx}/admin/goods/list.action">返回商品列表</a><br/>  
  8. <table border="1">  
  9.     <tr>  
  10.         <th>ID</th>  
  11.         <th>所属商品</th>  
  12.         <th>兑换码</th>  
  13.         <th>购买人</th>  
  14.         <th>兑换时间</th>  
  15.         <th>是否已经兑换</th>  
  16.         <th></th>  
  17.     </tr>  
  18.     <s:iterator value="page.items">  
  19.     <tr>  
  20.         <td><s:property value="id"/></td>  
  21.         <td><s:property value="goods.name"/></td>  
  22.         <td><s:property value="code"/></td>  
  23.         <td><s:property value="username"/></td>  
  24.         <td><s:date name="exchangeTime" format="yyyy-MM-dd"/></td>  
  25.         <td><s:property value="exchanged"/></td>  
  26.         <td>删除</td>  
  27.     </tr>     
  28.     </s:iterator>  
  29. </table>  
  30. <jsp:include page="../../common/inc/footer.jsp"/>  

 

 

右击“pointShop”选择【Run As】>【Run On Server】启动Web服务器，在浏览器中输入“http://localhost:8080/pointShop/admin/goods/list.action”，然后在指定商品后边点击【查看兑换码】将显示图11-15界面。

图11-15 商品兑换码列表

 

 

3.4、JSP实现商品兑换码新增页面（WEB-INF/jsp/admin/goodsCode/add.jsp）

 

用于新增指定商品的兑换码。

 

java代码：
Java代码  收藏代码
  1. <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
  2. <%@ include file="../../common/inc/tld.jsp"%>  
  3. <jsp:include page="../../common/inc/header.jsp">  
  4.     <jsp:param name="title" value="用户管理-新增"/>  
  5. </jsp:include>  
  6. <s:fielderror cssStyle="color:red"/>  
  7. <s:form action="/admin/goodsCode/add.action" method="POST" acceptcharset="UTF-8">  
  8. <s:token/>  
  9. <s:hidden name="goodsId" value="%{model.id}" />  
  10. <table border="1">  
  11.     <tr>  
  12.         <s:textfield label="所属商品" name="model.name" readonly="true"/>  
  13.     </tr>  
  14.     <tr>  
  15.         <s:textarea label="code码" name="codes" cols="20" rows="3"/>  
  16.     </tr>  
  17.     <tr>  
  18.        <td><input name="submit" type="submit" value="新增"/></td>  
  19.        <td><input name="cancel" type="button" onclick="javascript:window.location.href='${ctx}/admin/goodsCode/list.action?goodsId=<s:property value='%{model.id}'/>'" value="取消"/></td>  
  20.     </tr>     
  21. </table>  
  22. </s:form>  
  23. <jsp:include page="../../common/inc/footer.jsp"/>  

 

 

右击“pointShop”选择【Run As】>【Run On Server】启动Tomcat服务器，在商品兑换码列表中单击【新增】按钮将显示图11-16界面。

 

图11-16 兑换码新增页面

 

 

4、前台商品展示及购买模块：

 

前台商品展示提供商品展示及购买页面，购买时应考虑是否有足够兑换码等，此处错误消息使用硬编码，应该考虑使用国际化支持，请参考学习国际化。

 

4.1、Action实现

 

java代码：
Java代码  收藏代码
  1. package cn.javass.point.web.front.action;  
  2. //省略import  
  3. public class GoodsAction extends BaseAction {  
  4.     private static final String BUY_RESULT = "buyResult";  
  5.     public String list() {  
  6.         getValueStack().set(PAGE, goodsService.listAllPublished(getPn()));  
  7.         return LIST;  
  8.     }  
  9.     public String buy() {  
  10.         String username = "test";  
  11.         GoodsCodeModel goodsCode = null;  
  12.         try {  
  13.             goodsCode = goodsCodeService.buy(username, goodsId);  
  14.         } catch (NotCodeException e) {  
  15.             this.addActionError("没有足够的兑换码了");  
  16.             return BUY_RESULT;  
  17.         } catch (Exception e) {  
  18.             e.printStackTrace();  
  19.             this.addActionError("未知错误");  
  20.             return BUY_RESULT;  
  21.         }  
  22.         this.addActionMessage("购买成功，您的兑换码为 :"+ goodsCode.getCode());  
  23.         getValueStack().set(MODEL, goodsCode);  
  24.         return BUY_RESULT;  
  25.     }  
  26.     //字段驱动数据填充   
  27.     private int goodsId;  
  28.     //省略字段驱动数据的getter和setter  
  29.     //依赖注入Service  
  30.     IGoodsService goodsService;  
  31.     IGoodsCodeService goodsCodeService;  
  32.     //省略依赖注入的getter和setter  
  33. }  

 

 

4.2、Spring配置文件定义（resources/cn/javass/web/pointShop-front-servlet.xml）：

 

java代码：
Java代码  收藏代码
  1. <bean name="/front/goodsAction" class="cn.javass.point.web.front.action.GoodsAction" scope="prototype">  
  2.     <property name="goodsService" ref="goodsService"/>  
  3.     <property name="goodsCodeService" ref="goodsCodeService"/>  
  4. </bean>  

 

 

4.3、JSP实现前台商品展示及购买页面（WEB-INF/jsp/ goods/list.jsp）

 

java代码：
Java代码  收藏代码
  1. <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
  2. <%@ include file="../../common/inc/tld.jsp"%>  
  3. <jsp:include page="../../common/inc/header.jsp">  
  4.     <jsp:param name="title" value="积分商城-商品列表"/>  
  5. </jsp:include>  
  6. <s:iterator value="page.items" status="status">  
  7.        <s:property value="#status.index + 1"/>.<s:property value="name"/>  
  8.        <a href="${ctx}/goods/buy.action?goodsId=<s:property value='id'/>">【购买】</a><br/>  
  9.       描述：<s:property value="description"/><br/>  
  10.        <s>需要积分<s:property value="originalPoint"/></s>&nbsp;&nbsp;现需积分：<b><s:property value="nowPoint"/></b><br/>  
  11. </s:iterator>  
  12. <jsp:include page="../../common/inc/footer.jsp"/>  

 

右击“pointShop”选择【Run As】>【Run On Server】启动Web服务器，在浏览器中输入http://localhost:8080/pointShop/goods/list.action将显示图11-17界面。

 

图11-17 前台商品展示即购买页面

 

       在前台商品展示即购买页面中点击购买，如果库存中还有兑换码，将购买成功，否则购买失败。

 

 

4.3、商品购买结果页面（WEB-INF/jsp/admin/goods/buyResult.jsp）

 

购买成功将通过“<s:actionmessage/>”标签显示成功信息并将兑换码显示给用户，购买失败将通过“<s:actionerror/>”标签提示如积分不足或兑换码没有了等错误信息。

 

 

java代码：
Java代码  收藏代码
  1. <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
  2. <%@ include file="../../common/inc/tld.jsp"%>  
  3. <jsp:include page="../../common/inc/header.jsp">  
  4.     <jsp:param name="title" value="积分商城-购买结果"/>  
  5. </jsp:include>  
  6. <s:actionerror/>  
  7. <s:actionmessage/>  
  8. <jsp:include page="../../common/inc/footer.jsp"/>  

    在商品展示及购买列表购买成功或失败将显示图11-18或图11-19界面。

 

图11-18 购买成功页面

 

 

图11-19 购买失败页面

 

       到此SSH集成已经结束，集成SSH是非常简单的，但开发流程及开发思想是关键。

 

       我们整个开发过程是首先抽象和提取通用的模块和代码，这样可以复用减少开发时间，其次是基于通用层开发不可预测部分（即可变部分），因为每个项目的功能是不一样的。在开发过程中还集中将重复内容提取到一处这样方便以后修改。

0 0
python 遍历字符串 python 遍历字符串
原创粉丝点击
热门IT博客
张博士医考网络课试听张博士医考网络课试听
触摸屏幕软件触摸屏幕软件
ubuntu添加源
淘宝大学课程培训
程序员和工程师的区别
清华伯克利学院知乎
2k兰姆数据
外国人讨论中国 知乎
r软件官方下载
js判断是否显示隐藏
c语言多线程编程书籍
聚宝盆计划软件手机版
linux etc是什么意思
c语言中的数据类型
文华财经算法交易模型
陕西师范大学网络教育
mac的系统盘在哪里
网络摄像头手机客户端
Linux sh pl run
新点招投标制作软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 木耳腐竹 隔夜木耳 木耳隔夜 嫩木耳 腐竹炒木耳 炒木耳 白菜炒木耳 白菜木耳 腐竹木耳 酸辣木耳 木耳好处 木耳的拼音 干木耳 小木耳 木耳炒肉片 木耳肉片 小炒木耳 木耳炖鸡 木耳吧 泡木耳 木耳凉拌 木耳英文 木耳种植 木耳炒鸡 木耳粉 秋木耳 野生木耳 木耳粥 木耳汤 木耳长在哪 鲜木耳 木耳黑 粉红木耳 木耳价格 老醋木耳 木耳鸡蛋汤 木耳吃法 木耳炒 干木耳批发 吃木耳 木耳多少钱

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里