zoukankan      html  css  js  c++  java
  • 2.SSH 两个表全套增删改(运动员住宿管理)

    0、创建如下oracle的命令

     1 create table HOTALINFO
     2 (
     3   HOTALID      NUMBER(10) not null,
     4   HOTALNAME    VARCHAR2(50) not null,
     5   HOTALADDRESS VARCHAR2(100) not null
     6 )
     7 ;
     8 comment on table HOTALINFO
     9   is '酒店信息表';
    10 comment on column HOTALINFO.HOTALID
    11   is '酒店编号';
    12 comment on column HOTALINFO.HOTALNAME
    13   is '酒店名称';
    14 comment on column HOTALINFO.HOTALADDRESS
    15   is '酒店地址';
    16 alter table HOTALINFO
    17   add constraint PK_HOTALID primary key (HOTALID);
    18 
    19 
    20 create table SPORTSMAN
    21 (
    22   SPORTID     NUMBER(10) not null,
    23   SPORTNAME   VARCHAR2(50) not null,
    24   NATIONALITY VARCHAR2(50) not null,
    25   HOTALID     NUMBER(10) not null,
    26   INTAKETIME  DATE not null,
    27   LEAVETIME   DATE not null
    28 )
    29 ;
    30 
    31 comment on table SPORTSMAN
    32   is '运动员信息表';
    33 comment on column SPORTSMAN.SPORTID
    34   is '运动员编号';
    35 comment on column SPORTSMAN.SPORTNAME
    36   is '运动员姓名';
    37 comment on column SPORTSMAN.NATIONALITY
    38   is '国籍';
    39 comment on column SPORTSMAN.HOTALID
    40   is '酒店编号';
    41 comment on column SPORTSMAN.INTAKETIME
    42   is '入住时间';
    43 comment on column SPORTSMAN.LEAVETIME
    44   is '离开时间';
    45   
    46 alter table SPORTSMAN
    47   add constraint PK_SPORTID primary key (SPORTID);
    48 alter table SPORTSMAN
    49   add constraint FK_HOTELID foreign key (HOTALID)
    50   references HOTALINFO (HOTALID);
    51   
    52   -- Create sequence 
    53 create sequence SEQ_HOTALID
    54 minvalue 1
    55 maxvalue 999999
    56 start with 1
    57 increment by 1
    58 cache 30;
    59 
    60 create sequence SEQ_SPORTID
    61 minvalue 1
    62 maxvalue 99999
    63 start with 1
    64 increment by 1
    65 cache 30;
    66 
    67 
    68 insert into HOTALINFO (HOTALID, HOTALNAME, HOTALADDRESS)
    69 values (SEQ_HOTALID.nextval, '帝豪酒店', '南京中央门-30');
    70 insert into HOTALINFO (HOTALID, HOTALNAME, HOTALADDRESS)
    71 values (SEQ_HOTALID.nextval, '格林豪泰', '南京宣武门-30');
    72 insert into HOTALINFO (HOTALID, HOTALNAME, HOTALADDRESS)
    73 values (SEQ_HOTALID.nextval, '7天假日', '北京中央门-30');
    74 insert into HOTALINFO (HOTALID, HOTALNAME, HOTALADDRESS)
    75 values (SEQ_HOTALID.nextval, '99酒店', '南京大厂门-30');
    76 commit;
    77 
    78 
    79 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    80 values (SEQ_SPORTID.nextval, '张三', '英国', 1, to_date('05-04-2014', 'dd-mm-yyyy'), to_date('18-04-2014', 'dd-mm-yyyy'));
    81 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    82 values (SEQ_SPORTID.nextval, '李四', '韩国', 1, to_date('06-04-2014', 'dd-mm-yyyy'), to_date('17-04-2014', 'dd-mm-yyyy'));
    83 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    84 values (SEQ_SPORTID.nextval, '王五', '日本', 1, to_date('07-04-2014', 'dd-mm-yyyy'), to_date('16-04-2014', 'dd-mm-yyyy'));
    85 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    86 values (SEQ_SPORTID.nextval, '马六', '中国', 2, to_date('08-04-2014', 'dd-mm-yyyy'), to_date('15-04-2014', 'dd-mm-yyyy'));
    87 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    88 values (SEQ_SPORTID.nextval, '小猪', '法国', 3, to_date('09-04-2014', 'dd-mm-yyyy'), to_date('14-04-2014', 'dd-mm-yyyy'));
    89 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    90 values (SEQ_SPORTID.nextval, '菜菜', '外国', 4, to_date('10-04-2014', 'dd-mm-yyyy'), to_date('13-04-2014', 'dd-mm-yyyy'));
    91 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    92 values (SEQ_SPORTID.nextval, '放大', '是的', 4, to_date('03-03-2013', 'dd-mm-yyyy'), to_date('06-05-2014', 'dd-mm-yyyy'));
    93 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    94 values (SEQ_SPORTID.nextval, '答复', '', 1, to_date('03-03-2013', 'dd-mm-yyyy'), to_date('06-05-2014', 'dd-mm-yyyy'));
    95 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    96 values (SEQ_SPORTID.nextval, '11', '233', 3, to_date('05-04-2014', 'dd-mm-yyyy'), to_date('05-04-2014', 'dd-mm-yyyy'));
    97 insert into SPORTSMAN (SPORTID, SPORTNAME, NATIONALITY, HOTALID, INTAKETIME, LEAVETIME)
    98 values (SEQ_SPORTID.nextval, '按到', '中国', 4, to_date('03-03-2013', 'dd-mm-yyyy'), to_date('04-04-2014', 'dd-mm-yyyy'));
    99 commit;
    oracle的脚本

    1、项目实现如下功能

    (1)分页查询所有

     

    (2)分页查询下一页

    (3)、模糊查询

    (4)、模糊分页查询下一页

    (5)、修改第一条

    (6)、查看修改结果

    (7)、添加

    (8)、查看添加后的结果

    (9) 删除第二条查看删除结果

    2、创建如下项目结构

    3、在entity包下创建HotalInfo.java

     1 package com.entity;
     2 
     3 import java.io.Serializable;
     4 import java.util.HashSet;
     5 import java.util.Set;
     6 
     7 /**
     8  * 1.一方:酒店
     9  * @author Holly老师
    10  *
    11  */
    12 public class HotalInfo implements Serializable{
    13     private static final long serialVersionUID = 1L;
    14     /**
    15      * 酒店id
    16      */
    17     private Integer hotalid;
    18     /**
    19      * 酒店名称
    20      */
    21     private String hotalname;
    22     /**
    23      * 酒店地址
    24      */
    25     private String hotaladdress;
    26     
    27     /**
    28      * 一方引入set集合:一对多
    29      */
    30     private Set<Sportsman> sportsmans=new HashSet<Sportsman>();
    31     
    32     public HotalInfo() {
    33     }
    34     
    35     public HotalInfo(String hotalname, String hotaladdress) {
    36         this.hotalname = hotalname;
    37         this.hotaladdress = hotaladdress;
    38     }
    39     
    40 
    41     public HotalInfo(Integer hotalid, String hotalname, String hotaladdress) {
    42         this.hotalid = hotalid;
    43         this.hotalname = hotalname;
    44         this.hotaladdress = hotaladdress;
    45     }
    46     
    47 
    48     public HotalInfo(Integer hotalid, String hotalname, String hotaladdress,
    49             Set<Sportsman> sportsmans) {
    50         this.hotalid = hotalid;
    51         this.hotalname = hotalname;
    52         this.hotaladdress = hotaladdress;
    53         this.sportsmans = sportsmans;
    54     }
    55 
    56     public Integer getHotalid() {
    57         return hotalid;
    58     }
    59     public void setHotalid(Integer hotalid) {
    60         this.hotalid = hotalid;
    61     }
    62     public String getHotalname() {
    63         return hotalname;
    64     }
    65     public void setHotalname(String hotalname) {
    66         this.hotalname = hotalname;
    67     }
    68     public String getHotaladdress() {
    69         return hotaladdress;
    70     }
    71     public void setHotaladdress(String hotaladdress) {
    72         this.hotaladdress = hotaladdress;
    73     }
    74     
    75     public Set<Sportsman> getSportsmans() {
    76         return sportsmans;
    77     }
    78 
    79     public void setSportsmans(Set<Sportsman> sportsmans) {
    80         this.sportsmans = sportsmans;
    81     }
    82 
    83     @Override
    84     public String toString() {
    85         return "HotalInfo [hotaladdress=" + hotaladdress + ", hotalid="
    86                 + hotalid + ", hotalname=" + hotalname + "]";
    87     }
    88     
    89     
    90     
    91 
    92 }
    HotalInfo.java

    4、在entity包下创建Sportsman.java

      1 package com.entity;
      2 
      3 import java.util.Date;
      4 
      5 /**
      6  * 2.多方:运动员
      7  * @author Holly老师
      8  *
      9  */
     10 public class Sportsman {
     11     /**
     12      * 运动员编号
     13      */
     14     private Integer sportid;
     15     /**
     16      * 运动员姓名
     17      */
     18     private String sportname;
     19     /**
     20      * 国籍
     21      */
     22     private String nationality;
     23     /**
     24      * 入住时间
     25      */
     26     private Date intaketime;
     27     /**
     28      * 离开时间
     29      */
     30     private Date leavetime;
     31     
     32     /**
     33      * 多对一:配置对象
     34      */
     35     private HotalInfo hotalinfo;
     36     
     37     
     38     public Sportsman() {
     39     }
     40 
     41     public Sportsman(String sportname, String nationality, Date intaketime,
     42             Date leavetime, HotalInfo hotalinfo) {
     43         this.sportname = sportname;
     44         this.nationality = nationality;
     45         this.intaketime = intaketime;
     46         this.leavetime = leavetime;
     47         this.hotalinfo = hotalinfo;
     48     }
     49 
     50     public Sportsman(Integer sportid, String sportname, String nationality,
     51             Date intaketime, Date leavetime, HotalInfo hotalinfo) {
     52         this.sportid = sportid;
     53         this.sportname = sportname;
     54         this.nationality = nationality;
     55         this.intaketime = intaketime;
     56         this.leavetime = leavetime;
     57         this.hotalinfo = hotalinfo;
     58     }
     59 
     60     public Integer getSportid() {
     61         return sportid;
     62     }
     63 
     64     public void setSportid(Integer sportid) {
     65         this.sportid = sportid;
     66     }
     67 
     68     public String getSportname() {
     69         return sportname;
     70     }
     71 
     72     public void setSportname(String sportname) {
     73         this.sportname = sportname;
     74     }
     75 
     76     public String getNationality() {
     77         return nationality;
     78     }
     79 
     80     public void setNationality(String nationality) {
     81         this.nationality = nationality;
     82     }
     83 
     84     public Date getIntaketime() {
     85         return intaketime;
     86     }
     87 
     88     public void setIntaketime(Date intaketime) {
     89         this.intaketime = intaketime;
     90     }
     91 
     92     public Date getLeavetime() {
     93         return leavetime;
     94     }
     95 
     96     public void setLeavetime(Date leavetime) {
     97         this.leavetime = leavetime;
     98     }
     99 
    100     public HotalInfo getHotalinfo() {
    101         return hotalinfo;
    102     }
    103 
    104     public void setHotalinfo(HotalInfo hotalinfo) {
    105         this.hotalinfo = hotalinfo;
    106     }
    107 
    108     @Override
    109     public String toString() {
    110         return "Sportsman [hotalinfo=" + hotalinfo + ", intaketime="
    111                 + intaketime + ", leavetime=" + leavetime + ", nationality="
    112                 + nationality + ", sportid=" + sportid + ", sportname="
    113                 + sportname + "]";
    114     }
    115     
    116 
    117 }
    Sportsman.java

    5、在entity包下创建HotalInfo.hbm.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
     3 <hibernate-mapping>
     4   <!--一方配置: name是实体类的全路径,table是数据库表名-->
     5   <class name="com.entity.HotalInfo" lazy="false" table="HOTALINFO">
     6    
     7     <!-- 1.主键配置 ,name是类字段名。type是数据类型,column是列名-->
     8     <id name="hotalid" type="java.lang.Integer" column="HOTALID">
     9       <generator class="sequence">
    10           <!-- 主键是自增长序列 -->
    11           <param name="sequence">SEQ_HOTALID</param>
    12       </generator>
    13     </id>
    14     <!-- 2.普通属性配置 -->
    15     <property name="hotalname" type="java.lang.String"  column="HOTALNAME"/>
    16     <property name="hotaladdress" type="java.lang.String" column="HOTALADDRESS"/>
    17    
    18     <!-- 3. 一对多配置:-->
    19     <set name="sportsmans" table="SPORTSMAN">
    20       <!--外键列 -->
    21       <key column="HOTALID"></key>
    22       
    23       <!-- 集合对应的实体类路径 -->
    24       <one-to-many class="com.entity.Sportsman"/>
    25     </set>
    26   
    27   </class>
    28 </hibernate-mapping>
    HotalInfo.hbm.xml

    6、在entity包下创建Sportsman.hbm.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
     3 <hibernate-mapping>
     4   <!-- 多方配置: -->
     5   <class name="com.entity.Sportsman" table="SPORTSMAN">
     6      <!-- 1.主键配置 -->
     7      <id name="sportid" type="java.lang.Integer" column="SPORTID">
     8        <!-- 主键自增长 -->
     9        <generator class="sequence">
    10          <param name="sequence">SEQ_SPORTID</param>
    11        </generator>
    12      </id>
    13      <!-- 2.普通属性配置 -->
    14      <property name="sportname" type="java.lang.String" column="SPORTNAME"/>
    15      <property name="nationality" type="java.lang.String" column="NATIONALITY"/>
    16      <property name="intaketime" type="java.util.Date" column="INTAKETIME"/>
    17      <property name="leavetime" type="java.util.Date" column="LEAVETIME"/>
    18      
    19      <!-- 3.多对一配置 -->
    20      <!-- name是该类对应的外键类的对象名,class为外键类的全路径,column为外键列 -->
    21      <many-to-one name="hotalinfo" class="com.entity.HotalInfo" column="HOTALID"/>
    22   </class>
    23 </hibernate-mapping>
    Sportsman.hbm.xml

    7、在dao包下创建HotalInfoDao.java

     1 package com.dao;
     2 
     3 import java.util.List;
     4 
     5 import com.entity.HotalInfo;
     6 
     7 /**
     8  * 一方:酒店数据访问层接口
     9  * @author Holly老师
    10  *
    11  */
    12 public interface HotalInfoDao {
    13     /**
    14      * 1.查询所有
    15      * @return
    16      */
    17      public List<HotalInfo> query();
    18      /**
    19       * 2.根据id查询
    20       * @param id
    21       * @return
    22       */
    23      HotalInfo queryById(Integer id);
    24 
    25 }
    HotalInfoDao.java

    8、在dao包下创建SportsmanDao.java

     1 package com.dao;
     2 
     3 import java.util.List;
     4 
     5 import com.entity.Sportsman;
     6 
     7 /**
     8  * 多方:运动员数据访问层接口
     9  * @author Holly老师
    10  *
    11  */
    12 public interface SportsmanDao {
    13     /**
    14      * 1.分页查询
    15      * @param pageSize 页面大小
    16      * @param pageNo 当前页
    17      * @return 分页集合
    18      */
    19     List<Sportsman> queryPage(Integer pageSize,Integer pageNo);
    20     
    21     /**
    22      * 2.插入一个对象
    23      * @param obj 携带数据的对象
    24      * @return 受影响的行数
    25      */
    26     int insert(Sportsman obj);
    27     
    28     /**
    29      * 3.根据id删除
    30      * @param id
    31      * @return
    32      */
    33     int delete(Sportsman obj);
    34     
    35     /**
    36      * 4.修改对象
    37      * @param obj 携带数据的对象
    38      * @return  受影响的行数
    39      */
    40     int update(Sportsman obj);
    41     
    42     /**
    43      * 5.根据id查询
    44      * @param id
    45      * @return
    46      */
    47     Sportsman queryById(Integer id);
    48     
    49     /**
    50      * 6.查询总条数
    51      */
    52     Integer totalCount();
    53     
    54     /**
    55      * 7.模糊条件分页查询
    56      * @param pageSize 页面大小
    57      * @param pageNo  当前页
    58      * @param likeparam  模糊条件
    59      * @return
    60      */
    61     List<Sportsman> queryPageLike(Integer pageSize,Integer pageNo,String likeparam);
    62     /**
    63      * 8.模糊条件查询总条数
    64      * @return
    65      */
    66     Integer totalCountLike(String likeparam);
    67 }
    SportsmanDao.java

    9、在dao.impl包下创建HotalInfoDaoImpl.java

    package com.dao.impl;
    
    import java.util.List;
    
    import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
    
    import com.dao.HotalInfoDao;
    import com.entity.HotalInfo;
    /**
     * 一方:酒店
     * @author Holly老师
     *
     */
    public class HotalInfoDaoImpl extends HibernateDaoSupport implements HotalInfoDao {
        /**
         * 1.查询所有区域信息
         */
        public List<HotalInfo> query() {
            
            List<HotalInfo> list=getHibernateTemplate().find("from HotalInfo");
            
            return list;
        }
        /**
         * 2.根据id查询
         */
        public HotalInfo queryById(Integer id) {
            //根据主键查询
            HotalInfo hotalInfo=getHibernateTemplate().get(HotalInfo.class, id);
            return hotalInfo;
        }
    
    }
    HotalInfoDaoImpl.java

    10、在dao.impl包下创建SportsmanDaoImpl.java

      1 package com.dao.impl;
      2 
      3 import java.util.List;
      4 
      5 import org.hibernate.Query;
      6 import org.hibernate.Session;
      7 import org.springframework.dao.DataAccessException;
      8 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
      9 
     10 import com.dao.SportsmanDao;
     11 import com.entity.Sportsman;
     12 /**
     13  * 多方:运动员数据访问层实现类
     14  * @author Holly老师
     15  *
     16  */
     17 public class SportsmanDaoImpl extends HibernateDaoSupport 
     18           implements SportsmanDao {
     19     /**
     20      * 1.删除
     21      */
     22     public int delete(Sportsman obj) {
     23         try {
     24             getHibernateTemplate().delete(obj);
     25             
     26             return 1;
     27         } catch (DataAccessException e) {
     28             e.printStackTrace();
     29             return 0;
     30         }
     31     }
     32     /**
     33      * 2.添加
     34      */
     35     public int insert(Sportsman obj) {
     36         try {
     37             getHibernateTemplate().save(obj);
     38             return 1;
     39         } catch (DataAccessException e) {
     40             e.printStackTrace();
     41             return 0;
     42         }
     43     }
     44     /**
     45      * 3.根据id查询
     46      */
     47     public Sportsman queryById(Integer id) {
     48         try {
     49             //根据主键id查询
     50             Sportsman man=getHibernateTemplate().get(Sportsman.class, id);
     51             return man;
     52         } catch (DataAccessException e) {
     53             // TODO Auto-generated catch block
     54             e.printStackTrace();
     55             return null;
     56         }
     57     }
     58    /**
     59     * 4.分页查询
     60     */
     61     public List<Sportsman> queryPage(Integer pageSize, Integer pageNo) {
     62         //4.1 获取session对象
     63         Session session=getHibernateTemplate().getSessionFactory().openSession();
     64         
     65         //4.2 创建Query对象
     66         Query query=session.createQuery("from Sportsman");
     67         
     68         //4.3 查询起始行数据3-5
     69         query.setFirstResult((pageNo-1)*pageSize);
     70         
     71         //4.4 查询结束行数据
     72         query.setMaxResults(pageSize);
     73         
     74         //4.5 分页查询
     75         List<Sportsman> list=query.list();
     76          
     77         //4.6 关闭session(?)
     78         
     79         //4.7 返回集合
     80         return list;
     81     }
     82     /**
     83      * 5.模糊分页查询
     84      * 查询 运行员的信息
     85      */
     86     public List<Sportsman> queryPageLike(Integer pageSize, Integer pageNo,
     87             String likeparam) {
     88         //5.1 获取session对象
     89         Session session=getHibernateTemplate().getSessionFactory().openSession();
     90         
     91         //5.2 将string类型酒店id的类型转换为Integer 类型
     92         Integer id=Integer.parseInt(likeparam);
     93 //        Integer id=likeparam;
     94         
     95         //5.3定义hql语句
     96         String hql="from Sportsman a where a.hotalinfo.hotalid=:id";
     97         
     98         //5.4 创建Query对象
     99         Query query=session.createQuery(hql);
    100         
    101         //5.5为命名参数赋值(第一个id是sql中:id)
    102         query.setParameter("id", id);
    103         
    104         //5.6 查询起始行
    105         query.setFirstResult((pageNo-1)*pageSize);
    106         
    107         //5.7查询结束行
    108         query.setMaxResults(pageSize);
    109         
    110         //5.8 模糊分页查询
    111         List<Sportsman> list=query.list();
    112         
    113         //5.9 关闭session(?)
    114         //5.10 返回集合
    115         return list;
    116     }
    117     /**
    118      * 6.求出总记录数
    119      */
    120     public Integer totalCount() {
    121         //6.1  获取session对象
    122         Session session=getHibernateTemplate().getSessionFactory().openSession();
    123         
    124         //6.2 定义hql语句
    125         String hql="select count(*) from Sportsman";
    126         
    127         //6.3定义Query对象
    128         Query query=session.createQuery(hql);
    129         
    130         //6.4使用唯一结果查询方法
    131         String count=query.uniqueResult().toString();
    132         
    133         //6.5 Stirng 装换为integer
    134         Integer totalCount=Integer.parseInt(count);
    135         
    136         //6.6返回记录数
    137         return totalCount;
    138     }
    139     /**
    140      * 7.求模糊总记录条数
    141      */
    142     public Integer totalCountLike(String likeparam) {
    143         //7.1  获取session对象
    144         Session session=getHibernateTemplate().getSessionFactory().openSession();
    145         
    146         //7.2 定义hql语句
    147         String hql="select count(*) from Sportsman a " +
    148                 "where a.hotalinfo.hotalid=:id";
    149         
    150         //7.3 创建Query对象
    151         Query query=session.createQuery(hql);
    152         
    153         //7.4 id类型转换
    154         Integer id=Integer.parseInt(likeparam);
    155         
    156         //7.5 为命名参数赋值
    157         query.setParameter("id", id);
    158         
    159         //7.6 查询唯一结果
    160         String count=query.uniqueResult().toString();
    161         
    162         //7.7 类型转换
    163         Integer totalCount=Integer.parseInt(count);
    164         
    165         //7.8 返回记录数
    166         return totalCount;
    167     }
    168     
    169     /**
    170      * 8.修改
    171      */
    172     public int update(Sportsman obj) {
    173         try {
    174             getHibernateTemplate().update(obj);
    175             return 1;
    176         } catch (DataAccessException e) {
    177             e.printStackTrace();
    178             return 0;
    179         }
    180     }
    181 
    182 }
    SportsmanDaoImpl.java

    11、在service包下创建HotalInfoService.java

     1 package com.service;
     2 
     3 import java.util.List;
     4 
     5 import com.entity.HotalInfo;
     6 
     7 /**
     8  * 一方:酒店业务接口
     9  * @author Holly老师
    10  *
    11  */
    12 public interface HotalInfoService {
    13     /**
    14      * 1.查询所有
    15      * @return
    16      */
    17      public List<HotalInfo> query();
    18      /**
    19       * 2.根据id查询
    20       * @param id
    21       * @return
    22       */
    23      HotalInfo queryById(Integer id);
    24 
    25     
    26 
    27 }
    HotalInfoService.java

    12、在service包下创建SportsmanService.java

     1 package com.service;
     2 
     3 import java.util.List;
     4 
     5 import com.entity.Sportsman;
     6 
     7 /**
     8  * 运动员数据访问层接口
     9  * @author Holly老师
    10  *
    11  */
    12 public interface SportsmanService {
    13     /**
    14      * 1.分页查询
    15      * @param pageSize 页面大小
    16      * @param pageNo 当前页
    17      * @return 分页集合
    18      */
    19     List<Sportsman> queryPage(Integer pageSize,Integer pageNo);
    20     
    21     /**
    22      * 2.插入一个对象
    23      * @param obj 携带数据的对象
    24      * @return 受影响的行数
    25      */
    26     int insert(Sportsman obj);
    27     
    28     /**
    29      * 3.根据id删除
    30      * @param id
    31      * @return
    32      */
    33     int delete(Sportsman obj);
    34     
    35     /**
    36      * 4.修改对象
    37      * @param obj 携带数据的对象
    38      * @return  受影响的行数
    39      */
    40     int update(Sportsman obj);
    41     
    42     /**
    43      * 5.根据id查询
    44      * @param id
    45      * @return
    46      */
    47     Sportsman queryById(Integer id);
    48     
    49     /**
    50      * 6.查询总条数
    51      */
    52     Integer totalCount();
    53     
    54     /**
    55      * 7.模糊条件分页查询
    56      * @param pageSize 页面大小
    57      * @param pageNo  当前页
    58      * @param likeparam  模糊条件
    59      * @return
    60      */
    61     List<Sportsman> queryPageLike(Integer pageSize,Integer pageNo,String likeparam);
    62     /**
    63      * 8.模糊条件查询总条数
    64      * @return
    65      */
    66     Integer totalCountLike(String likeparam);
    67 }
    SportsmanService.java

    13、在service.impl包下创建HotalInfoServiceImpl.java

     1 package com.service.impl;
     2 
     3 import java.util.List;
     4 
     5 import com.dao.HotalInfoDao;
     6 import com.entity.HotalInfo;
     7 import com.service.HotalInfoService;
     8 /**
     9  * 一方:业务逻辑接口
    10  * @author Holly老师
    11  *
    12  */
    13 public class HotalInfoServiceImpl implements HotalInfoService {
    14     /**
    15      * 在spring中注入数据访问
    16      */
    17     private HotalInfoDao oneDao;
    18     
    19     public HotalInfoDao getOneDao() {
    20         return oneDao;
    21     }
    22 
    23     public void setOneDao(HotalInfoDao oneDao) {
    24         this.oneDao = oneDao;
    25     }
    26 
    27     /**
    28     * 查询所有
    29     */
    30     public List<HotalInfo> query() {
    31         
    32         return oneDao.query();
    33     }
    34     /**
    35      * 根据id查询
    36      */
    37     public HotalInfo queryById(Integer id) {
    38         
    39         return oneDao.queryById(id);
    40     }
    41 
    42 }
    HotalInfoServiceImpl.java

    14、在service.impl包下创建SportsmanServiceImpl.java

     1 package com.service.impl;
     2 
     3 import java.util.List;
     4 
     5 import com.dao.SportsmanDao;
     6 import com.entity.Sportsman;
     7 import com.service.SportsmanService;
     8 /**
     9  *多方:业务逻辑接口实现类
    10  * @author Holly老师
    11  *
    12  */
    13 public class SportsmanServiceImpl implements SportsmanService {
    14     /**
    15      * Spring中注入数据访问层dao:多方
    16      */
    17     private SportsmanDao manyDao;
    18     
    19     public SportsmanDao getManyDao() {
    20         return manyDao;
    21     }
    22 
    23     public void setManyDao(SportsmanDao manyDao) {
    24         this.manyDao = manyDao;
    25     }
    26     /**
    27      * 1.删除
    28      */
    29     public int delete(Sportsman obj) {
    30         // TODO Auto-generated method stub
    31         return manyDao.delete(obj);
    32     }
    33 /**
    34  * 2.添加
    35  */
    36     public int insert(Sportsman obj) {
    37         return manyDao.insert(obj);
    38     }
    39 /**
    40  * 3.根据id查询
    41  */
    42     public Sportsman queryById(Integer id) {
    43         return manyDao.queryById(id);
    44     }
    45 /**
    46  * 4.普通分页查询
    47  */
    48     public List<Sportsman> queryPage(Integer pageSize, Integer pageNo) {
    49         return manyDao.queryPage(pageSize, pageNo);
    50     }
    51 /**
    52  * 5.模糊分页查询
    53  */
    54     public List<Sportsman> queryPageLike(Integer pageSize, Integer pageNo,
    55             String likeparam) {
    56         // TODO Auto-generated method stub
    57         return manyDao.queryPageLike(pageSize, pageNo, likeparam);
    58     }
    59 /**
    60  * 6.获取总条数
    61  */
    62     public Integer totalCount() {
    63         return manyDao.totalCount();
    64     }
    65 /**
    66  * 7.条件查询总条数
    67  */
    68     public Integer totalCountLike(String likeparam) {
    69         // TODO Auto-generated method stub
    70         return manyDao.totalCountLike(likeparam);
    71     }
    72 /**
    73  * 8.修改
    74  */
    75     public int update(Sportsman obj) {
    76         // TODO Auto-generated method stub
    77         return manyDao.update(obj);
    78     }
    79 
    80 }
    SportsmanServiceImpl.java

    15、在action包下创建SportsmanAction.java

      1 package com.action;
      2 
      3 import java.util.ArrayList;
      4 import java.util.List;
      5 
      6 import javax.servlet.http.HttpServletRequest;
      7 import javax.servlet.http.HttpSession;
      8 
      9 import org.apache.struts2.ServletActionContext;
     10 import org.hibernate.mapping.Array;
     11 
     12 import com.entity.HotalInfo;
     13 import com.entity.Sportsman;
     14 import com.opensymphony.xwork2.ActionSupport;
     15 import com.service.HotalInfoService;
     16 import com.service.SportsmanService;
     17 /**
     18  * 多方:控制层
     19  * @author Holly老师
     20  *
     21  */
     22 public class SportsmanAction extends ActionSupport {
     23     /**
     24      * 1.在Spring中注入service层对象
     25      */
     26     private HotalInfoService oneService; //一方service
     27     private SportsmanService manyService; //多方service
     28     
     29     /**
     30      * 3.Struts 给一方对象注入数据
     31      */
     32     private HotalInfo oneObj;
     33     
     34     /**
     35      * 3.Struts 给多方对象注入数据
     36      * @return
     37      */
     38     private Sportsman manyObj;
     39     
     40     
     41     /**
     42      * 4.查询单条
     43      * @return
     44      */
     45     public String findById(){
     46         //6.1 获取request对象
     47         HttpServletRequest request=ServletActionContext.getRequest();
     48         
     49         //6.2 判断参数id是否接到
     50         if(manyObj!=null){
     51             Integer id=manyObj.getSportid();
     52             
     53             //6.2.1 根据id查询
     54             Sportsman many=manyService.queryById(id);
     55             //6.2.2 对象放入
     56             request.setAttribute("many", many);
     57             return SUCCESS;
     58             
     59         }else{
     60             System.out.println("id没有接到");
     61             return ERROR;
     62         }
     63     }
     64     
     65     
     66     /**
     67      * 5.分页查询和模糊分页查询
     68      * @return
     69      */
     70     public String likePage(){
     71        //5.1 获取request对象
     72         HttpServletRequest request=ServletActionContext.getRequest();
     73       
     74         //5.2 获取pageNo参数
     75         String no=request.getParameter("pageNo");
     76         
     77         //5.3 转换
     78         Integer pageNo=1;
     79         if(no!=null){
     80             pageNo=Integer.parseInt(no);
     81         }
     82         
     83         
     84         //5.4 获取输入框的的条件
     85         Integer param=0;
     86         if(manyObj!=null){
     87             //通过struts2注入的对象中获取值
     88             param= manyObj.getHotalinfo().getHotalid();
     89             System.out.println("输入框值:"+param);
     90         }
     91         
     92         
     93         //由于后台传递的是String ,所以这里
     94         String likeparam=param.toString();
     95         
     96         //5.5 定义页面大小
     97         Integer pageSize=3;
     98         
     99         //5.6 判断模糊分页和普通分页
    100         List<Sportsman> list=new ArrayList<Sportsman>();
    101         Integer totalCount=null;
    102         Integer totalPage=null;
    103         if(likeparam!=null && !likeparam.equals("0")){
    104             //5.6.1  获取条件区域id模糊分页查询集合
    105             list=manyService.queryPageLike(pageSize, pageNo, likeparam);
    106             
    107             for (Sportsman sportsman : list) {
    108                 System.out.println(sportsman);
    109             }
    110             //5.6.2  查询总条数
    111             totalCount= manyService.totalCountLike(likeparam);
    112             
    113             //5.6.3 计算总页数
    114             totalPage=totalCount%pageSize==0?totalCount/pageSize:totalCount/pageSize+1;
    115             
    116             //5.6.4 将前台需要的数据给request
    117             request.setAttribute("list", list);
    118             request.setAttribute("totalCount", totalCount);
    119             request.setAttribute("totalPage", totalPage);
    120             request.setAttribute("pageNo", pageNo);
    121             request.setAttribute("likeparam", likeparam);
    122             //**
    123       
    124         }else{
    125             //5.7 查询所有分页
    126             list=manyService.queryPage(pageSize, pageNo);
    127             
    128             //5.6.2  查询总条数
    129             totalCount= manyService.totalCount();
    130             
    131             //5.6.3 计算总页数
    132             totalPage=totalCount%pageSize==0?totalCount/pageSize:totalCount/pageSize+1;
    133             
    134             // 获取session对象
    135             HttpSession session=request.getSession();
    136             
    137             //查询one放所有数据
    138             List<HotalInfo> onelist=oneService.query();
    139             // 
    140             session.setAttribute("onelist", onelist);
    141             
    142             //将前台需要的数据给request
    143             request.setAttribute("list", list);
    144             request.setAttribute("totalCount", totalCount);
    145             request.setAttribute("totalPage", totalPage);
    146             request.setAttribute("pageNo", pageNo);
    147             request.setAttribute("likeparam", likeparam);
    148         
    149         }
    150         System.out.println("likeparam:"+likeparam);
    151         return SUCCESS;
    152     }
    153     
    154     
    155     /**
    156      * 6.修改
    157      * @return
    158      */
    159     public String updateMany(){
    160         if(manyObj!=null){
    161              HotalInfo one =oneService.queryById(manyObj.getHotalinfo().getHotalid());
    162              System.out.println("修改one:"+one);
    163              
    164              manyObj.setHotalinfo(one);
    165              HttpServletRequest request=ServletActionContext.getRequest();
    166             System.out.println("修改many:"+manyObj);
    167             
    168             Integer num=manyService.update(manyObj);
    169             return SUCCESS;
    170         }else{
    171             return ERROR;
    172         }
    173         
    174     }
    175     /**
    176      * 7.删除
    177      * @return
    178      */
    179     public String deleteMany(){
    180         if(manyObj!=null){
    181             //根据多方的id重新查询整条数据=对象
    182             Sportsman many=manyService.queryById(manyObj.getSportid());
    183             //删除对象
    184             Integer num=manyService.delete(many);
    185             return SUCCESS;
    186         }else{
    187             return ERROR;
    188         }
    189         
    190     }
    191     /**
    192      * 8.添加 
    193      */
    194     public String insertMany(){
    195         //判断多方对象是否为空
    196         if( manyObj!=null){
    197             System.out.println("save的manyObj:"+manyObj);
    198             //根据多方中一方对象属性的id查询,一方数据
    199             HotalInfo one=oneService.queryById(manyObj.getHotalinfo().getHotalid());
    200             
    201             //将查询到的一方数据赋值给多方的一方对象属性
    202             manyObj.setHotalinfo(one);
    203             
    204             //多方的添加操作
    205             Integer num=manyService.insert(manyObj) ;
    206             if(num>0){
    207                 System.out.println("添加查询");
    208                 return SUCCESS;
    209             }else{
    210                 System.out.println("添加失败");
    211                 return ERROR;
    212             }
    213         }else{
    214             System.out.println("save没接到manyObj:"+manyObj);
    215             return ERROR;
    216             
    217         }
    218     }
    219     
    220     
    221     public HotalInfoService getOneService() {
    222         return oneService;
    223     }
    224     public void setOneService(HotalInfoService oneService) {
    225         this.oneService = oneService;
    226     }
    227     public SportsmanService getManyService() {
    228         return manyService;
    229     }
    230     public void setManyService(SportsmanService manyService) {
    231         this.manyService = manyService;
    232     }
    233     public HotalInfo getOneObj() {
    234         return oneObj;
    235     }
    236     public void setOneObj(HotalInfo oneObj) {
    237         this.oneObj = oneObj;
    238     }
    239     public Sportsman getManyObj() {
    240         return manyObj;
    241     }
    242     public void setManyObj(Sportsman manyObj) {
    243         this.manyObj = manyObj;
    244     }
    245     
    246     
    247     
    248 
    249 }
    SportsmanAction.java

    16、在WebRoot下WEB-INF下创建applicationContext.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans" 
     3 xmlns:aop="http://www.springframework.org/schema/aop" 
     4 xmlns:context="http://www.springframework.org/schema/context" 
     5 xmlns:tx="http://www.springframework.org/schema/tx" 
     6 xmlns:mvc="http://www.springframework.org/schema/mvc" 
     7 xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
     8 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     9 xsi:schemaLocation="http://www.springframework.org/schema/beans 
    10 http://www.springframework.org/schema/beans/spring-beans.xsd
    11 http://www.springframework.org/schema/aop
    12 http://www.springframework.org/schema/aop/spring-aop.xsd
    13 http://www.springframework.org/schema/context
    14 http://www.springframework.org/schema/context/spring-context.xsd
    15 http://www.springframework.org/schema/tx
    16 http://www.springframework.org/schema/tx/spring-tx.xsd
    17 http://www.springframework.org/schema/mvc
    18 http://www.springframework.org/schema/mvc/spring-mvc.xsd
    19  ">
    20  
    21  <!-- 1.定义数据源 -->
    22  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    23    <property name="driverClass" value="oracle.jdbc.driver.OracleDriver"/>
    24    <property name="jdbcUrl" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl"/>
    25    <property name="user" value="ssh"/>
    26    <property name="password" value="sys"/>
    27    <!-- 最小连接数 -->
    28    <property name="minPoolSize" value="1"/>
    29    <!-- 最大连接数 -->
    30    <property name="maxPoolSize" value="100"/>
    31    <!-- 初始化连接数 -->
    32    <property name="initialPoolSize" value="1"/>
    33    <!-- 最大等待时间 -->
    34    <property name="maxIdleTime" value="30"/>
    35  </bean>
    36  
    37  <!-- 2.创建Session工厂 :地址session工厂bean-->
    38  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    39     <!-- 2.1 注入数据源 -->
    40     <property name="dataSource" ref="dataSource"/>
    41     
    42     <!-- 2.2 注册引入映射的hibernate的xml文件 -->
    43     <property name="mappingResources">
    44       <list>
    45         <value>com/entity/HotalInfo.hbm.xml</value>
    46         <value>com/entity/Sportsman.hbm.xml</value>
    47       </list>
    48     </property>
    49     
    50     <!-- 2.3 hibernate显示sql,格式化,方言配置 -->
    51     <property name="hibernateProperties">
    52       <props>
    53         <prop key="hibernate.show_sql">true</prop>
    54         <prop key="hibernate.format_sql">true</prop>
    55         <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
    56       </props>
    57     </property>
    58  </bean>
    59  
    60  <!-- 3.事务管理 -->
    61  <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
    62    <property name="sessionFactory" ref="sessionFactory"/>
    63  </bean>
    64  
    65  
    66  <!-- 4.dao注入session -->
    67  <!-- id任意的 -->
    68  <bean id="oneDao" class="com.dao.impl.HotalInfoDaoImpl">
    69    <property name="sessionFactory" ref="sessionFactory"/>
    70  </bean> 
    71  <bean id="manyDao" class="com.dao.impl.SportsmanDaoImpl">
    72    <property name="sessionFactory" ref="sessionFactory"/>
    73  </bean>
    74  
    75  <!-- 5.service注入dao -->
    76  <bean id="oneService" class="com.service.impl.HotalInfoServiceImpl">
    77     <!-- name是固定的,ref的值是上一个bean的id -->
    78     <property name="oneDao" ref="oneDao"/>
    79  </bean>
    80  <bean id="manyService" class="com.service.impl.SportsmanServiceImpl">
    81     <!-- name是固定的,ref的值是上一个bean的id -->
    82     <property name="manyDao" ref="manyDao"/>
    83  </bean>
    84  
    85  <!-- 6.action注入service -->
    86  <bean id="manyAction" class="com.action.SportsmanAction" scope="prototype">
    87    <property name="oneService" ref="oneService"/>
    88    <property name="manyService" ref="manyService"/>
    89  </bean>
    90 </beans>
    applicationContext.xml

    17、在src下创建struts.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN" "struts-2.1.7.dtd" >
     3 <struts>
     4   <!-- 乱码处理 -->
     5   <constant name="struts.i18n.encoding" value="UTF-8"/>
     6   <package name="default" namespace="/" extends="struts-default">
     7      <!-- 全局配置 -->
     8      <global-results>
     9        <result name="error">error.jsp</result>
    10      </global-results>
    11      
    12      <!-- 注意全局配置和默认action首启项不能同时存在,并且,默认首期项,在web.xml,拦截的时候最好不要设置为以.action结尾才会起作用, -->
    13      <!--  
    14      <default-action-ref name="page"/>
    15      -->
    16      <!-- name是请求的action的地址,
    17      class是spring中注入的action的bean的id,
    18      method是action类中对应的方法 -->
    19      <!-- 分页查询 和模糊分页查询-->
    20      <action name="page" class="manyAction" method="likePage">
    21        <result name="success">index.jsp</result>
    22      </action>
    23      
    24      <!-- 删除  -->
    25      <action name="delete" class="manyAction" method="deleteMany">
    26         <result name="success" type="redirectAction">page</result>
    27      </action>
    28      
    29      <!-- 查询单条 -->
    30      <action name="findById" class="manyAction" method="findById">
    31          <result name="success">update.jsp</result>
    32      </action>
    33      
    34      <!-- 修改 -->
    35      <action name="update" class="manyAction" method="updateMany">
    36         <result name="success" type="redirectAction">page</result>
    37      </action>
    38      
    39      <!-- 添加 -->
    40      <action name="save" class="manyAction" method="insertMany">
    41         <result name="success" type="redirectAction">page</result>
    42      </action>
    43   </package>
    44 </struts>
    struts.xml

    18、在WebRoot下WEB-INF下创建web.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <web-app version="2.5" 
     3     xmlns="http://java.sun.com/xml/ns/javaee" 
     4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     5     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
     6     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
     7 <!--    -->
     8  <listener>
     9     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    10   </listener>
    11 
    12   <filter>
    13     <filter-name>struts2</filter-name>
    14     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    15   </filter>
    16   <filter-mapping>
    17     <filter-name>struts2</filter-name>
    18     <url-pattern>*.action</url-pattern>
    19   </filter-mapping>
    20   
    21   <filter>
    22     <filter-name>characterEncodingFilter</filter-name>
    23     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    24     <init-param>
    25       <param-name>encoding</param-name>
    26       <param-value>UTF-8</param-value>
    27     </init-param>
    28   </filter>
    29   <filter-mapping>
    30     <filter-name>characterEncodingFilter</filter-name>
    31     <url-pattern>/</url-pattern>
    32   </filter-mapping>
    33   <welcome-file-list>
    34     <welcome-file>index.jsp</welcome-file>
    35   </welcome-file-list>
    36 </web-app>
    web.xml

    19、在WebRoot下创建index.jsp

      1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
      2 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
      3 <%
      4 String path = request.getContextPath();
      5 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
      6 %>
      7 
      8 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
      9 <html>
     10   <head>
     11     <base href="<%=basePath%>">
     12     
     13     <title>My JSP 'index.jsp' starting page</title>
     14     <meta http-equiv="pragma" content="no-cache">
     15     <meta http-equiv="cache-control" content="no-cache">
     16     <meta http-equiv="expires" content="0">    
     17     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
     18     <meta http-equiv="description" content="This is my page">
     19     <!--
     20     <link rel="stylesheet" type="text/css" href="styles.css">
     21     -->
     22   </head>
     23   
     24   <body>
     25     <center>
     26       <h3>运动员住宿管理系统</h3>
     27       <table border="1">
     28         <tr>
     29           <td colspan="7">
     30           <form action="page.action" method="post">
     31                 酒店:<select name="manyObj.hotalinfo.hotalid">
     32                     <option value="0" selected="selected">不限</option> 
     33                
     34                         <c:forEach var="i" items="${onelist}" >
     35                             <c:choose>
     36                               <c:when test="${likeparam eq i.hotalid}">
     37                                 <option value="${i.hotalid}" selected="selected">${i.hotalname}</option> 
     38                               </c:when>
     39                             <c:otherwise>
     40                                 <option value="${i.hotalid}">${i.hotalname}</option> 
     41                             </c:otherwise>
     42                             </c:choose>
     43                         </c:forEach>
     44                  
     45                 
     46                </select>
     47                <input type="submit" value="查询"/>
     48                <a href="add.jsp">添加运动员信息</a>
     49           </form>
     50           </td>
     51         </tr>
     52         <tr><td>序号</td><td>酒店名称</td><td>酒店地址</td>
     53         <td>运动员姓名</td><td>入住时间</td><td>离开时间</td><td>操作</td></tr>
     54         <c:forEach var="i" items="${list}">
     55         
     56         <tr><td>${i.sportid}</td><td>${i.hotalinfo.hotalname}</td>
     57         <td>${i.hotalinfo.hotaladdress}</td>
     58         <td>${i.sportname}</td>
     59         <td>${i.intaketime}</td>
     60         <td>${i.leavetime}</td>
     61         <td>
     62             <a href="findById.action?manyObj.sportid=${i.sportid}">修改</a>
     63             <a href="delete.action?manyObj.sportid=${i.sportid}">删除</a></td>
     64         </tr>
     65         </c:forEach>
     66         <tr><td colspan="7" align="center">
     67         
     68         <c:choose>
     69           <c:when test="${likeparam eq 0}">
     70           
     71              第${pageNo}/${totalPage}页  &nbsp;&nbsp;
     72           <a href="page.action?pageNo=${pageNo}">首页</a> &nbsp;&nbsp;
     73           <c:choose>
     74             <c:when test="${pageNo gt 1}">
     75               <a href="page.action?pageNo=${pageNo-1}">上一页</a> &nbsp;&nbsp;
     76             </c:when>
     77             <c:otherwise>
     78               <a href="javascript:alert('已经是第一页!');">上一页</a> &nbsp;&nbsp;
     79             </c:otherwise>
     80           </c:choose>
     81           
     82           <c:choose>
     83             <c:when test="${pageNo lt totalPage}">
     84               <a href="page.action?pageNo=${pageNo+1}">下一页</a> &nbsp;&nbsp;
     85             </c:when>
     86             <c:otherwise>
     87               <a href="javascript:alert('已经是最后一页!');">上一页</a> &nbsp;&nbsp;
     88             </c:otherwise>
     89           </c:choose>
     90           
     91           <a href="page.action?pageNo=${totalPage}">末页</a> &nbsp;&nbsp;
     92            共${totalCount}条
     93           
     94              
     95           
     96           </c:when>
     97           
     98           <c:otherwise>
     99           
    100                      第${pageNo}/${totalPage}页  &nbsp;&nbsp;
    101           <a href="page.action?pageNo=${pageNo}&manyObj.hotalinfo.hotalid=${likeparam}">首页</a> &nbsp;&nbsp;
    102           <c:choose>
    103             <c:when test="${pageNo gt 1}">
    104               <a href="page.action?pageNo=${pageNo-1}&manyObj.hotalinfo.hotalid=${likeparam}">上一页</a> &nbsp;&nbsp;
    105             </c:when>
    106             <c:otherwise>
    107               <a href="javascript:alert('已经是第一页!');">上一页</a> &nbsp;&nbsp;
    108             </c:otherwise>
    109           </c:choose>
    110           
    111           <c:choose>
    112             <c:when test="${pageNo lt totalPage}">
    113               <a href="page.action?pageNo=${pageNo+1}&manyObj.hotalinfo.hotalid=${likeparam}">下一页</a> &nbsp;&nbsp;
    114             </c:when>
    115             <c:otherwise>
    116               <a href="javascript:alert('已经是最后一页!');">上一页</a> &nbsp;&nbsp;
    117             </c:otherwise>
    118           </c:choose>
    119           
    120           <a href="page.action?pageNo=${totalPage}&manyObj.hotalinfo.hotalid=${likeparam}">末页</a> &nbsp;&nbsp;
    121            共${totalCount}条
    122            
    123           </c:otherwise>
    124         </c:choose>
    125                      
    126            
    127         </td>
    128         </tr>
    129       </table>
    130     </center>
    131   </body>
    132 </html>
    index.jsp

    20、在WebRoot下创建add.jsp

     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
     3 <%
     4 String path = request.getContextPath();
     5 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
     6 %>
     7 
     8 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     9 <html>
    10   <head>
    11     <base href="<%=basePath%>">
    12     
    13     <title>My JSP 'update.jsp' starting page</title>
    14     
    15     <meta http-equiv="pragma" content="no-cache">
    16     <meta http-equiv="cache-control" content="no-cache">
    17     <meta http-equiv="expires" content="0">    
    18     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    19     <meta http-equiv="description" content="This is my page">
    20     <!--
    21     <link rel="stylesheet" type="text/css" href="styles.css">
    22     -->
    23 
    24   </head>
    25   
    26   <body>
    27      <center>
    28            <h3>添加运动员信息</h3>
    29            <form action="save.action" method="post">
    30            <table border="1">
    31               <tr>
    32                   <td>酒店:</td>
    33                   <td>
    34                         <select name="manyObj.hotalinfo.hotalid">
    35                         <option value="0" selected="selected">不限</option> 
    36                         <c:forEach var="i" items="${onelist}" >
    37                             <c:choose>
    38                               <c:when test="${likeparam eq i.hotalid}">
    39                                 <option value="${i.hotalid}" selected="selected">${i.hotalname}</option> 
    40                               </c:when>
    41                             <c:otherwise>
    42                                 <option value="${i.hotalid}">${i.hotalname}</option> 
    43                             </c:otherwise>
    44                             </c:choose>
    45                         </c:forEach>
    46                     </select>
    47                   </td>
    48               </tr>
    49               <tr><td>运动员姓名:</td>
    50                   <td><input type="text" name="manyObj.sportname"/></td>
    51               </tr>
    52               <tr><td>国籍:</td>
    53                   <td><input type="text" name="manyObj.nationality"/></td>
    54               </tr>
    55               <tr><td>入住时间:</td><td><input type="text" name="manyObj.intaketime"/></td></tr>
    56               <tr><td>离店时间:</td><td><input type="text" name="manyObj.leavetime"/></td></tr>
    57               <tr><td colspan="2" align="center">
    58                 <input type="submit" value="添加"/>
    59                 <input type="reset" value="取消"/>
    60               </td></tr>
    61            </table>
    62            </form>
    63      </center>
    64   </body>
    65 </html>
    add.jsp

    21、在WebRoot下创建update.jsp

     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
     3 <%
     4 String path = request.getContextPath();
     5 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
     6 %>
     7 
     8 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     9 <html>
    10   <head>
    11     <base href="<%=basePath%>">
    12     
    13     <title>My JSP 'update.jsp' starting page</title>
    14     
    15     <meta http-equiv="pragma" content="no-cache">
    16     <meta http-equiv="cache-control" content="no-cache">
    17     <meta http-equiv="expires" content="0">    
    18     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    19     <meta http-equiv="description" content="This is my page">
    20     <!--
    21     <link rel="stylesheet" type="text/css" href="styles.css">
    22     -->
    23 
    24   </head>
    25   
    26   <body>
    27      <center>
    28            <h3>运动员信息维护页</h3>
    29            <form action="update.action?manyObj.sportid=${many.sportid}" method="post">
    30            <table border="1">
    31               <tr>
    32                   <td>酒店:</td>
    33                   <td>
    34                         <select name="manyObj.hotalinfo.hotalid">
    35                         <option value="0" selected="selected">不限</option> 
    36                         <c:forEach var="i" items="${onelist}" >
    37                             <c:choose>
    38                               <c:when test="${likeparam eq i.hotalid}">
    39                                 <option value="${i.hotalid}" selected="selected">${i.hotalname}</option> 
    40                               </c:when>
    41                             <c:otherwise>
    42                                 <option value="${i.hotalid}">${i.hotalname}</option> 
    43                             </c:otherwise>
    44                             </c:choose>
    45                         </c:forEach>
    46                     </select>
    47                   </td>
    48               </tr>
    49               <tr><td>运动员姓名:</td>
    50                   <td><input type="text" name="manyObj.sportname" value="${many.sportname}"/></td>
    51               </tr>
    52               <tr><td>国籍:</td>
    53                   <td><input type="text" name="manyObj.nationality" value="${many.nationality}"/></td>
    54               </tr>
    55               <tr><td>入住时间:</td><td><input type="text" name="manyObj.intaketime" value="${many.intaketime}"/></td></tr>
    56               <tr><td>离店时间:</td><td><input type="text" name="manyObj.leavetime" value="${many.leavetime}"/></td></tr>
    57               <tr><td colspan="2" align="center">
    58                 <input type="submit" value="更新"/>
    59                 <input type="reset" value="取消"/>
    60               </td></tr>
    61            </table>
    62            </form>
    63      </center>
    64   </body>
    65 </html>
    update.jsp
  • 相关阅读:
    LeetCode 18. 4Sum (四数之和)
    开运算、闭运算、形态学梯度、顶帽、黑帽
    膨胀和腐蚀
    四种滤波方式
    关于平滑处理及图像滤波与滤波器
    27、简述redis的有哪几种持久化策略及比较?
    26、redis中默认有多少个哈希槽?
    25、如何实现redis集群?
    大聊Python----Select解析
    大聊Python----IO口多路复用
  • 原文地址:https://www.cnblogs.com/holly8/p/5547956.html
Copyright © 2011-2022 走看看