GVKun编程网logo

使用Hibernate将下拉列表值保存到Struts 2中的数据库中（将下拉列表封装为一个组件）

14

如果您想了解使用Hibernate将下拉列表值保存到Struts2中的数据库中和将下拉列表封装为一个组件的知识，那么本篇文章将是您的不二之选。我们将深入剖析使用Hibernate将下拉列表值保存到St

如果您想了解使用Hibernate将下拉列表值保存到Struts 2中的数据库中和将下拉列表封装为一个组件的知识，那么本篇文章将是您的不二之选。我们将深入剖析使用Hibernate将下拉列表值保存到Struts 2中的数据库中的各个方面，并为您解答将下拉列表封装为一个组件的疑在这篇文章中，我们将为您介绍使用Hibernate将下拉列表值保存到Struts 2中的数据库中的相关知识，同时也会详细的解释将下拉列表封装为一个组件的运用方法，并给出实际的案例分析，希望能帮助到您！

本文目录一览：

使用Hibernate将下拉列表值保存到Struts 2中的数据库中（将下拉列表封装为一个组件）

使用Hibernate将下拉列表值保存到Struts 2中的数据库中（将下拉列表封装为一个组件）

我想将下拉列表的选定值保存到数据库中。

首先index.jsp被加载。单击的注册URL，从index.jsp可以转到。register.jsp``index.jsp

struts.xml ：

<action name="registerAction"method="populateSelect">        <result name="success" >register.jsp</result>    </action>    <action name="register"method="execute">        <result name="success" >login.jsp</result>    </action>

index.jsp ：

  <s:url id="url" action="registerAction"></s:url>  <s:a href="%{url}">Register</s:a>

register.jsp ：

   <s:form action="registerAction" method="execute">     <s:select label="Select Date of Month" key="Month List" name="months" headerKey="0" headerValue="--Select--" list="allMonths" listKey="id" listValue="name"/> <s:submit value="Register"/> </s:form>

动作类是：

public class RegisterAction extends ActionSupport {    String name, pwd, email, address, months;    int phno;    List<Month> allMonths = new ArrayList<Month>();    List<User> users = new ArrayList<User>();    UserDao udao = new UserDao();public List<Month> getAllMonths() {    return allMonths;}public void setAllMonths(List<Month> allMonths) {    this.allMonths = allMonths;}public String getMonths() {    return months;}public void setMonths(String months) {    this.months = months;}public List<User> getUsers() {    return users;}public void setUsers(List<User> users) {    this.users = users;}public String getAddress() {    return address;}public void setAddress(String address) {    this.address = address;}public String getEmail() {    return email;}public void setEmail(String email) {    this.email = email;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public int getPhno() {    return phno;}public void setPhno(int phno) {    this.phno = phno;}public String getPwd() {    return pwd;}public void setPwd(String pwd) {    this.pwd = pwd;}    public RegisterAction() {    }    public String execute() throws Exception {        User u = new User();        u.setName(name);        u.setEmail(email);        u.setAddress(address);        u.setPhno(phno);        u.setPwd(pwd);        System.out.println("Hi der "+months);        u.setMonths(months);        udao.addUser(u);        return "success";    }    public String listAllUsers() {        users = udao.getUsers();        System.out.println("In Action, " + users);        return "success";    }    public String populateSelect() {        allMonths = udao.getMonths();        System.out.println("In constructor " + allMonths);        return "success";    }}

下拉列表实际上只是表单字段之一。表单中还有其他字段。可以将月份以外的所有其他值输入数据库。对于月份字段，输入的值为空。

我认为下拉菜单的价值并未得到体现。

答案1

小编典典

我建议将months成员变量更改为Map如下形式：

private Map<Integer, String> months = new HashMap<Integer, String>();

然后，Preparable在您的操作中实现该接口，并使用以下内容初始化地图：

public void prepare() throws Exception {    String[] monthNames = new DateFormatSymbols().getMonths();    int i = 1;    for (String monthName : monthNames) {        months.put(i++, monthName);    }}

当然，您需要为添加一个getter和setter months

另外，private Integer month在您的操作中添加一个成员变量，该变量将保留用户选择的月份（同样，具有getter和setter方法）

然后，s:select在您的JSP中使用以下标记：

<s:select label="Select Date of Month" name="month" headerKey="0"          headerValue="--Select--" list="months"/>

因此，现在在您的execute方法中，month成员变量应保存所选的月份。0应该没有选择，1应该是一月，依此类推。

Ajax+Struts+Hibernate 实现级联下拉单

Ajax+Struts+Hibernate 实现级联下拉单

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>kind.html</title>
  <script type="text/javascript" src="js/common.js"></script>
  <script type="text/javascript">...
    function refreshModelList()...{ 
      var oneName=document.getElementById("kindone").value;
      if(oneName=="")...{
        clearlist();
        return;
      }
      var url="kind.do?method=search&&kindid="+oneName;
     
      createXMLHttpRequest();
      
      xmlHttp.onreadystatechange=handleStateChange;
      xmlHttp.open("GET",url,true);
      xmlHttp.send(null);
      
    }
    function handleStateChange()...{
      if(xmlHttp.readyState==4)...{ 
        if(xmlHttp.status==200)...{
          setNames(); 
        }
      }
    }
    function clearlist()...{
      var models=document.getElementById("kindtwo");
      while(models.childNodes.length>0)...{
        models.removeChild(models.childNodes[0]);
      }
    }
    function setNames()...{
      clearlist();
      var models=document.getElementById("kindtwo");
      var xmlDoc=xmlHttp.responseXML;
      var results=xmlDoc.getElementsByTagName("kind");
      var option=null;
      for(var i=0;i<results.length;i++)...{
        option=document.createElement("option");
        option.appendChild(document.createTextNode(results[i].firstChild.nodeValue));
        models.appendChild(option);
      }
    }
  </script>
  </head>
  
  <body>
    <h2>dynamicLists</h2>
    <select id="kindone" onchange="refreshModelList();">
      <option value="1">a</option>
      <option value="2">b</option>
      <option value="3">c</option>
      <option value="4">d</option>
    </select>
    <select id="kindtwo">
    </select>
  </body>
</html>/**//*
 * Generated by MyEclipse Struts
 * Template path: templates/java/JavaClass.vtl
 */
package com.rain.struts.action; 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import org.apache.struts.validator.DynaValidatorForm;

import com.rain.bean.KindDao;

/** *//** 
 * MyEclipse Struts
 * Creation date: 09-13-2006
 * 
 * XDoclet definition:
 * @struts.action parameter="method"
 */
public class KindAction extends DispatchAction ...{
 /**//*
  * Generated Methods
  */

 /** *//** 
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public ActionForward search(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) ...{
  DynaValidatorForm kindForm = (DynaValidatorForm)form;
  KindDao dao=new KindDao();
  int kindid=Integer.parseInt(kindForm.getString("kindid"));
  List list=dao.findAllKind(kindid);
  Iterator it=list.iterator();
  if(it.hasNext())...{
   PrintWriter out;
   try ...{
    response.setContentType("text/xml;charset=UTF-8");
    response.setHeader("Cache-Control", "no-cache");
    out = response.getWriter();

    out.println("<response>");
    while(it.hasNext())...{
     String name=it.next().toString();
     out.println("<kind>"+name+"</kind>");
    }
    out.println("</response>");
    it=null;
    out.close();
   } catch (IOException e) ...{
    // TODO 自动生成 catch 块
    e.printStackTrace();
   }
   
  }else...{
   response.setStatus(HttpServletResponse.SC_NO_CONTENT);
  }
  // TODO Auto-generated method stub
  return null;
 }
}

Ajax+Struts+Hibernate实现级联下拉单

Ajax+Struts+Hibernate实现级联下拉单

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>kind.html</title>
  <script type="text/javascript" src="js/common.js"></script>
  <script type="text/javascript">...
    function refreshModelList()...{ 
      var oneName=document.getElementById("kindone").value;
      if(oneName=="")...{
        clearlist();
        return;
      }
      var url="kind.do?method=search&&kindid="+oneName;
     
      createXMLHttpRequest();
      
      xmlHttp.onreadystatechange=handleStateChange;
      xmlHttp.open("GET",url,true);
      xmlHttp.send(null);
      
    }
    function handleStateChange()...{
      if(xmlHttp.readyState==4)...{ 
        if(xmlHttp.status==200)...{
          setNames(); 
        }
      }
    }
    function clearlist()...{
      var models=document.getElementById("kindtwo");
      while(models.childNodes.length>0)...{
        models.removeChild(models.childNodes[0]);
      }
    }
    function setNames()...{
      clearlist();
      var models=document.getElementById("kindtwo");
      var xmlDoc=xmlHttp.responseXML;
      var results=xmlDoc.getElementsByTagName("kind");
      var option=null;
      for(var i=0;i<results.length;i++)...{
        option=document.createElement("option");
        option.appendChild(document.createTextNode(results[i].firstChild.nodeValue));
        models.appendChild(option);
      }
    }
  </script>
  </head>
  
  <body>
    <h2>dynamicLists</h2>
    <select id="kindone" onchange="refreshModelList();">
      <option value="1">a</option>
      <option value="2">b</option>
      <option value="3">c</option>
      <option value="4">d</option>
    </select>
    <select id="kindtwo">
    </select>
  </body>
</html>/**//*
 * Generated by MyEclipse Struts
 * Template path: templates/java/JavaClass.vtl
 */
package com.rain.struts.action; 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import org.apache.struts.validator.DynaValidatorForm;

import com.rain.bean.KindDao;

/** *//** 
 * MyEclipse Struts
 * Creation date: 09-13-2006
 * 
 * XDoclet definition:
 * @struts.action parameter="method"
 */
public class KindAction extends DispatchAction ...{
 /**//*
  * Generated Methods
  */

 /** *//** 
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public ActionForward search(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) ...{
  DynaValidatorForm kindForm = (DynaValidatorForm)form;
  KindDao dao=new KindDao();
  int kindid=Integer.parseInt(kindForm.getString("kindid"));
  List list=dao.findAllKind(kindid);
  Iterator it=list.iterator();
  if(it.hasNext())...{
   PrintWriter out;
   try ...{
    response.setContentType("text/xml;charset=UTF-8");
    response.setHeader("Cache-Control", "no-cache");
    out = response.getWriter();

    out.println("<response>");
    while(it.hasNext())...{
     String name=it.next().toString();
     out.println("<kind>"+name+"</kind>");
    }
    out.println("</response>");
    it=null;
    out.close();
   } catch (IOException e) ...{
    // TODO 自动生成 catch 块
    e.printStackTrace();
   }
   
  }else...{
   response.setStatus(HttpServletResponse.SC_NO_CONTENT);
  }
  // TODO Auto-generated method stub
  return null;
 }
}

Hibernate 中把一对多关系的数据保存到数据库

Hibernate 中把一对多关系的数据保存到数据库

用Hibernate做持久层的时候,在保存一对多关系的数据的时候,把主表端的inverse设为true,在JAVA对象里把关联做成双向,一次保存主表,效率最高.

下面以往主表保存一条数据，子表保存两条数据为例： 

1,通过保存主表的方式,inverse设为true,JAVA对象做双向关联,通过跟踪Hibernate的SQL,发现一共有三次insert操作.

如果不将子表方关联到主表方(将子表JAVA对象加到主表的set里),子表里不会插入数据,只产生1条插入主表的SQL.

如果不将主表方关联到子表方(将主表JAVA对象赋值到子表对象的对应属性),同样有三次insert操作,但是子表的外键值为空.

需要设置主表的mapping文件:

        <set name="detailtbs" inverse="true" lazy="true" table="DETAILTB" cascade="all-delete-orphan" fetch="select">
            <key>
                <column name="MID" precision="22" scale="0" />
            </key>
            <one-to-many/>
        </set>

            MasttbHome masttbHome = new MasttbHome();      
           
            Masttb masttb = new Masttb();
            masttb.setMid(new BigDecimal(1));
            masttb.setMastinfo("mastinfo");
           
            //如果不如下那样把主表对象关联到子表JAVA对象,子表的外键会为空
            Detailtb detailtb1 = new Detailtb(new BigDecimal(1),masttb,"detailinfo1");
            Detailtb detailtb2 = new Detailtb(new BigDecimal(2),masttb,"detailinfo2");
            //如果不把子表的对象加入到主表的set里,不会插入子表数据.
            masttb.getDetailtbs().add(detailtb1);
            masttb.getDetailtbs().add(detailtb2);
           
            masttbHome.persist(masttb);

2,通过保存主表的方式,如果将inverse设为false,JAVA代码里面可以只把子表方的对象加到主表对象的set里面,进行单向关联,保存主表,会产生3条SQL insert语句,2条update(update 子表)语句.做双向关联也是3条SQL insert语句,2条update(update 子表)语句.

如果不将子表方关联到主表方(将子表JAVA对象加到主表的set里),子表里不会插入数据,只产生1条插入主表的SQL. 

如下例3:

        <set name="detailtbs" inverse="false" lazy="true" table="DETAILTB" cascade="all-delete-orphan" fetch="select">
            <key>
                <column name="MID" precision="22" scale="0" />
            </key>
            <one-to-many/>
        </set>

            MasttbHome masttbHome = new MasttbHome();      
           
            Masttb masttb = new Masttb();
            masttb.setMid(new BigDecimal(1));
            masttb.setMastinfo("mastinfo");
           
           
            Detailtb detailtb1 = new Detailtb();
            detailtb1.setDtid(new BigDecimal(1));
            detailtb1.setDetailinfo("detailinfo1");
           
            Detailtb detailtb2 = new Detailtb();
            detailtb2.setDtid(new BigDecimal(2));
            detailtb2.setDetailinfo("detailinfo2");

            //只将子表关联加到主表对象,主表必须 inverse="false"
            masttb.getDetailtbs().add(detailtb1);
            masttb.getDetailtbs().add(detailtb2);
           
            masttbHome.persist(masttb);

 

*如果主表 inverse="true",就必须把主表关联到子表方:

            detailtb1.setMasttb(masttb);

            detailtb2.setMasttb(masttb);

否则子表里的外键就没有被赋值.

3,下面的代码是通过保存子表的方式,inverse="false",只是在多方的JAVA对象里做了关联,通过跟踪Hibernate的SQL,发现有3条SQL insert语句,1条select(select主表)语句,2条update(update子表)语句.

如果是做了双向关联,,发现有3条SQL insert语句,1条select(select主表)语句,4条update(update子表)语句(由于子表cascade="save-update"的原因).

如果不将主表关联到子表对象,只会往子表插入数据,如果外键定义了不能为空限制,会有异常.

需要设置子表的mapping文件:

        <many-to-one name="masttb"cascade="save-update" fetch="join">
            <column name="MID" precision="22" scale="0" />
        </many-to-one>

           
            Masttb masttb = new Masttb();
            masttb.setMid(new BigDecimal(1));
            masttb.setMastinfo("mastinfo");
           
            Detailtb detailtb1 = new Detailtb(new BigDecimal(1),masttb,"detailinfo1");
            Detailtb detailtb2 = new Detailtb(new BigDecimal(2),masttb,"detailinfo2");


            //masttb.getDetailtbs().add(detailtb1);
            //masttb.getDetailtbs().add(detailtb2);


            DetailtbHome detailtbHome = new DetailtbHome();
            detailtbHome.persist(detailtb1);
            detailtbHome.persist(detailtb2);

 

*:在用来做保存的对象对应的mapping文件必须设cascade为关联保存,如,用主表关联保存,如例1,需要在set方加上cascade为级联保存.如果是在子表,需要在子表方加上cascade为级联保存,如例3.

 

inverse的作用:

inverse只能用在多方(set/map/list/array/bag),推荐做法是设为true,同时在JAVA代码里面对对象进行双向关联.如上面的例子那样.

4,通过保存子表的方式,inverse设为true,JAVA代码里面只把主表方的对象关联到子表方里面,进行单向关联,产生3条SQL insert语句,1条select(select主表)语句,2条update(子表)语句.

如果在JAVA对象做双向关联,SQL的效果和单向一样.

如果不将主表关联到子表对象,只会往子表插入数据,如果外键定义了不能为空限制,会有异常.

如下例5:

主表mapping:

        <set name="detailtbs" inverse="true" lazy="true" table="DETAILTB" cascade="all-delete-orphan" fetch="select">
            <key>
                <column name="MID" precision="22" scale="0" />
            </key>
            <one-to-many/>
        </set>

子表mapping:

        <many-to-one name="masttb"   cascade="save-update" fetch="join">
            <column name="MTID" precision="22" scale="0" />
        </many-to-one>

JAVA代码:

            tx = sessionFactory.getCurrentSession().beginTransaction();
           
            Masttb masttb = new Masttb();
            masttb.setMid(new BigDecimal(1));
            masttb.setMastinfo("mastinfo");
            //可以只做多方做单向关联:
            Detailtb detailtb1 = new Detailtb(new BigDecimal(1),masttb,"detailinfo1");
            Detailtb detailtb2 = new Detailtb(new BigDecimal(2),masttb,"detailinfo2");

 

            //做双向关联不会影响SQL:
            //masttb.getDetailtbs().add(detailtb1);
            //masttb.getDetailtbs().add(detailtb2);

            DetailtbHome detailtbHome = new DetailtbHome();
            detailtbHome.persist(detailtb1);
            detailtbHome.persist(detailtb2);
            tx.commit();

 

总结:

1,最基本的原则:

如果保存主表的方式,必须将子表的对象加到主表对应的对象集合属性里.

如果保存子表的方式,必须将主表的对象赋值给子表对应的对象的属性里.

2,inverse=true的时候

如果保存主表的方式,必须做双向关联,否则,子表的外键就会为空值.

如果保存子表的方式,可以只将主表的对象赋值给子表对应的对象的属性里,但是会产生不必要的SQL操作.

3,inverse=false的时候

如果保存主表的方式,可以只将子表的对象加到主表对应的对象集合属性里.但是会产生不必要的SQL操作.

如果保存子表的方式,可以只将主表的对象赋值给子表对应的对象的属性里,但是会产生不必要的SQL操作.

 

inverse为true的意思是当hibernate探测到关联的持久化对象的关联状态发生变化的时候,按照子表的改变来更新数据库,从而避免不必要的SQl操作,子表方的cascade也会影响SQL的操作.


最佳做法是,保存主表,在JAVA里做双向关联,inverse设为true.(一般子表的cascade设为none).

 


原文链接： http://blog.csdn.net/kkdelta/article/details/5349358

Hibernate 查询数据库中的数据

Hibernate 查询数据库中的数据

1.Criteria介绍

Criteria与Session绑定，其生命周期跟随着Session结束而结束，使用Criteria时进行查询时，每次都要于执行时期动态建立物件，并加入各种查询条件，随着Session的回收，Criteria也跟着回收。

org.hibernate.Criteria实际上是个条件附加的容器，如果想要设定查询条件，则要使用org.hibernate.criterion.Restrictions的各种静态方法传回org.hibernate.criterion.Criteria实例，传回的每个org.hibernate.criterion.Criteria实例代表着一个条件。

2.Criterion介绍

Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来添加查询条件。Criterion 的实例可以通过 Restrictions 工具类来创建，Restrictions 提供了大量的静态方法，如 eq （等于）、 ge （大于等于）、 between 等来方法的创建 Criterion 查询条件。除此之外， Restrictions 还提供了方法来创建 conjunction 和disjunction 实例，通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合。

3.Restrictions的几个常用限定查询方法如下表所示：

Restrictions.eq --> equal,等于.

Restrictions.allEq --> 参数为Map对象,使用key/value进行多个等于的比对,相当于多个Restrictions.eq 的效果

Restrictions.gt --> great-than > 大于

Restrictions.ge --> great-equal >= 大于等于

Restrictions.lt --> less-than, < 小于

Restrictions.le --> less-equal <= 小于等于

Restrictions.between --> 对应SQL的between子句

Restrictions.like --> 对应SQL的LIKE子句

Restrictions.in --> 对应SQL的in子句

Restrictions.and --> and 关系

Restrictions.or --> or 关系

Restrictions.isNull --> 判断属性是否为空,为空则返回true  相当于SQL的 is null

Restrictions.isNotNull --> 与isNull相反     相当于SQL的 is not null

Restrictions.sqlRestriction --> SQL限定的查询

Order.asc --> 根据传入的字段进行升序排序

Order.desc --> 根据传入的字段进行降序排序

MatchMode.EXACT --> 字符串精确匹配.相当于"like ''value''"

MatchMode.ANYWHERE --> 字符串在中间匹配.相当于"like ''%value%''"

MatchMode.START --> 字符串在最前面的位置.相当于"like ''value%''"

MatchMode.END --> 字符串在最后面的位置.相当于"like ''%value''"

4.实例应用

(1)多个条件("与"的方式进行查询)

//利用hibernate对数据库中的StudentEntity表进行查询，将查询结果放入一个集合返回
    public static List<StudentEntity> queryStudentByUserInput(String studentname, String realAddress, String riskrank){
        //1.创建一个session对象
        Session session1=HibernateTools.getSession();
        //2.通过session的createCriteria创建一个Criteria 对象
        Criteria criteria=session1.createCriteria(StudentEntity.class);
        //3. Criteria.add 增加约束(连续加入两个条件，达到"与"的效果),Restrictions.like()方法中的参数1为数据库表的实体类的成员变量，参数2为筛选内容，参数3为匹配方式
        criteria.add(Restrictions.like("name",studentname,MatchMode.ANYWHERE))
        .add(Restrictions.like("address","天",MatchMode.ANYWHERE));
        //4.调用list()方法返回查询结果的集合
        List<StudentEntity> studentinfolist=criteria.list();
        //开启一个新的事务Transaction
        session1.beginTransaction();
        //提交事务，此处才是真正与数据库交互的语句
        session1.getTransaction().commit();
        HibernateTools.closeSession();
        return studentinfolist;
    }

(2)多个条件("或"的方式进行查询)

//利用hibernate对数据库中的StudentEntity表进行查询，将查询结果放入一个集合返回
    public static List<StudentEntity> queryStudentByUserInput(String studentname, String realAddress, String riskrank){
        //1.创建一个session对象
        Session session1=HibernateTools.getSession();
        //2.通过session的createCriteria创建一个Criteria 对象
        Criteria criteria=session1.createCriteria(StudentEntity.class);
        //3. Criteria.add 增加约束(连续加入两个条件，达到"或"的效果)[筛选条件为：name属性中有"l"的，或address属性中有"天"或"金"]
        criteria.add(Restrictions.or(Restrictions.like("name", "l",MatchMode.ANYWHERE),
                Restrictions.or(Restrictions.like("address", "天",MatchMode.ANYWHERE),Restrictions.like("address", "金",MatchMode.ANYWHERE))));
        //4.调用list()方法返回查询结果的集合
        List<StudentEntity> studentinfolist=criteria.list();
        //开启一个新的事务Transaction
        session1.beginTransaction();
        //提交事务，此处才是真正与数据库交互的语句
        session1.getTransaction().commit();
        HibernateTools.closeSession();
        return studentinfolist;
    }

 参考文献：https://my.oschina.net/u/2266102/blog/425601(极具参考价值)

我们今天的关于使用Hibernate将下拉列表值保存到Struts 2中的数据库中和将下拉列表封装为一个组件的分享已经告一段落，感谢您的关注，如果您想了解更多关于Ajax+Struts+Hibernate 实现级联下拉单、Ajax+Struts+Hibernate实现级联下拉单、Hibernate 中把一对多关系的数据保存到数据库、Hibernate 查询数据库中的数据的相关信息，请在本站查询。

本文标签：

上一篇使用Apache Commons文件上载API在Jsp中上载多个文件（apache运行jsp）

下一篇WEB-INF下的Struts 2 Convention Plugin和JSP文件（web-inf下的jsp怎么访问）

相关文章