（一）
（1）struts2与hibernate的整合
（2）创建相关类库并且导入需要的jar包
导入：
配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>学生管理</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 接下来就是进行配置，配置一个过滤器 ,filter-name表示自定义的过滤器的名称。filter-class：过滤器需要实现Filter接口-->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<!-- 配置过滤器的映射，filter-name和上面的名称是一样的，url-pattern表示过滤器要过滤的路径，在这里是所有路径都要过滤。 -->
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>在src目录下创建struts.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<!-- 所有匹配*.action的请求都由struts2处理
<constant name="struts.action.extension" value="action" />
是否启用开发模式
<constant name="struts.devMode" value="true" />
struts配置文件改动后，是否重新加载
<constant name="struts.configuration.xml.reload" value="true" />
设置浏览器是否缓存静态内容
<constant name="struts.serve.static.browserCache" value="false" />
请求参数的编码方式
<constant name="struts.i18n.encoding" value="utf-8" />
每次HTTP请求系统都重新加载资源文件，有助于开发
<constant name="struts.i18n.reload" value="true" />
文件上传最大值
<constant name="struts.multipart.maxSize" value="104857600" />
让struts2支持动态方法调用
<constant name="struts.enable.DynamicMethodInvocation" value="true" />
Action名称中是否还是用斜线
<constant name="struts.enable.SlashesInActionNames" value="false" />
允许标签中使用表达式语法
<constant name="struts.tag.altSyntax" value="true" />
对于WebLogic,Orion,OC4J此属性应该设置成true
<constant name="struts.dispatcher.parametersWorkaround" value="false" /> -->
<package name="default" namespace="/" extends="struts-default">
</package>
<package name="users" namespace="/users" extends="default" >
<!-- method是Action中 方法，class是路径，{1}是第一个*，-->
<action name="*_*" class="action.{1}Action" method="{2}" >
<!-- name="login_success"表示在UsersAction类中的login方法中的返回的值，对应了/users/Users_login_success.jsp页面。-->
<result name="login_success">/users/Users_login_success.jsp</result>
<result name="login_failure">/users/Users_login.jsp</result>
</action>
</package>
</struts>然后在src目录下创建hibernate.cfg.xml配置文件：
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!--声明Hibernate配置文件的开始-->
<hibernate-configuration>
<!--表明以下的配置是针对session-factory配置的，SessionFactory是Hibernate中的一个类，
这个类主要负责保存HIbernate的配置信息，以及对Session的操作-->
<session-factory >
<!-- 这是链接mysql数据库的配置 -->
<!--连接数据库是用户名,下面的name中可以在前面加上hibernate，比如：
<property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate</hibernate>
-->
<property name="connection.username">root</property>
<!--连接数据库是密码-->
<property name="connection.password">root</property>
<!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!--设置数据库的连接url:jdbc:mysql://localhost/hibernate,其中localhost表示mysql服务器名称，此处为本机， hibernate是数据库名-->
<property name="connection.url">jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8</property>
<!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于查错，程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。
项目部署后可以设置为false，提高运行效率-->
<property name="show_sql">true</property>
<!-- 输出格式化后的sql,更方便查看 -->
<property name="format_sql">true</property>
<!-- 最常用的值，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据 model类自动更新表结构，
即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等 应用第一次运行起来后才会 -->
<property name="hbm2ddl.auto">update</property>
<!-- 这样配置是本地jdbc事务配置,你通过getCurrentSession创建的session会绑定到当前线程 -->
<property name="hibernate.current_session_context_class">thread</property>
<!-- 将映射文件加到hibernate.cfg.xml配置文件中（是xml文件就用resource） -->
<mapping resource="entity/Students.hbm.xml"></mapping>
<mapping resource="entity/Users.hbm.xml"></mapping>
</session-factory>
</hibernate-configuration>（3）创建实体类
package entity;
import java.util.Date;
//学生类
public class Students {
private String sid;
private String sname;
private String gender;
private Date birthday;
private String address;//地址
public Students() {
}
public Students(String sid, String sname, String gender, Date birthday, String address) {
super();
this.sid = sid;
this.sname = sname;
this.gender = gender;
this.birthday = birthday;
this.address = address;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
//在这里为了便于测试，写下面的方法
@Override
public String toString() {
return "Students [sid=" + sid + ", sname=" + sname + ", gender=" + gender + ", birthday=" + birthday
+ ", address=" + address + "]";
}
}
package entity;
public class Users {
private int uid;
private String username;
private String password;
public Users() {
}
public Users(int uid, String username, String password) {
//super();
this.uid = uid;
this.username = username;
this.password = password;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
（4）然后在enetity包中创建实体映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping >
<!-- table="USERS"表示 在数据库中的表名称-->
<class name="entity.Students" table="STUDENTS">
<id name="sid" type="java.lang.String" column="SID" length="8">
<!-- 表示id是递增的.assigned：用户自定义id;在这里也是因为sid是string类型的-->
<generator class="assigned"></generator>
</id>
<property name="sname" type="java.lang.String"/>
<property name="gender" type="java.lang.String"/>
<property name="birthday" type="date"/>
<property name="address" type="java.lang.String"/>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping >
<!-- table="USERS"表示 在数据库中的表名称-->
<class name="entity.Users" table="USERS">
<id name="uid" type="int" column="id">
<!-- 表示id是递增的-->
<generator class="native"></generator>
</id>
<property name="username" type="java.lang.string"/>
<property name="password" type="java.lang.string"/>
</class>
</hibernate-mapping>
还要注意将映射文件加到hibernate.cfg.xml配置文件中（是xml文件就用resource）：
<!-- 将映射文件加到hibernate.cfg.xml配置文件中（是xml文件就用resource） -->
<mapping resource="entity/Students.hbm.xml"></mapping>
<mapping resource="entity/Users.hbm.xml"></mapping>（5）使用SchemaExport生成表结构，在这个项目中让Junit使用SchemaExport：
在项目中建立一个Test源文件测试生成表结构是否没有问题，创建一个TestStudents生成表结构：
package entity;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;
public class TestStudents {
//@Test注解要写在你要测试的方法上面
//然后点击--运行方式,再点击Junit测试，就可以了。@Test的使用 是该方法可以不用main方法调用就可以测试出运行结果，是一种测试方法
//一般函数都需要有main方法调用才能执行
@Test
public void testSchemaExport() {//通过这个测试方法来生成表结构
//创建配置对象
Configuration config=new Configuration().configure();
//创建服务注册对象
ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
//创建sessionFactory
SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);
//创建session对象
Session session=sessionFactory.getCurrentSession();
//创建SchemaExport对象
SchemaExport export=new SchemaExport(config);
//生成表结构,第一个参数表示生成表结构，第二个参数表示输出sql语句
export.create(true,true);
}
}
注意，在数据库中现在没有建立表，只是有test数据库，在运行成功后会自动创建students与users2个表；
（二）用户登录模块
（1）项目分层
实体层是entity，接口层和接口实现层分别是service和serviceimpl，数据库层是db，动作层是action。
（2）创建MyHibernateSessionFactory
创建自定义的session工厂类，在db包中创建MyHibernateSessionFactory类：
package db;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
public class MyHibernateSessionFactory {
//会话工厂属性
private static SessionFactory sessionFactory;
//构造方法私有化，保证单例模式
private MyHibernateSessionFactory() {
}
//共有的静态方法，获得会话工厂对象
public static SessionFactory getSessionFactory() {
if(sessionFactory==null) {
//创建配置对象
Configuration config=new Configuration().configure();
//创建服务注册对象
ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
//创建sessionFactory
sessionFactory=config.buildSessionFactory(serviceRegistry);
return sessionFactory;
}else {
return sessionFactory;
}
}
}
（3）设计用户接口以及对应的实现类
package service;
import entity.Users;
/**
* 用户业务逻辑接口
* @author 26326
*
*/
public interface UsersDAO {
//用户登录方法
public boolean usersLogin(Users u) ;
}
package service.impl;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import db.MyHibernateSessionFactory;
import entity.Users;
import service.UsersDAO;
public class UsersDAOImpl implements UsersDAO {
//用户登录的具体实现方法
public boolean usersLogin(Users u) {
//事务对象
Transaction tx=null;
//hql的查询语句
String hql="";
try {
//用自己创建的MyHibernateSessionFactory获得一个会话对象
Session session=MyHibernateSessionFactory.getSessionFactory().getCurrentSession();
//开启事务
tx=session.beginTransaction();
//hql语句
hql="from Users where username=? and password=? ";
/*
* createQuery与createSQLQuery两者区别是：
前者用的hql语句进行查询，后者可以用sql语句查询
前者以hibernate生成的Bean为对象装入list返回
后者则是以对象数组进行存储
*/
Query query=session.createQuery(hql);
//（JDBC的下标从1开始，Hibernate的下标从0开始）
query.setParameter(0, u.getUsername());
query.setParameter(1, u.getPassword());
List list=query.list();
tx.commit();//提交事务，在返回之前提交
//判断是否查到对应的用户
if(list.size()>0) {
return true;
}
else {
return false;
}
}catch(Exception ex) {
ex.printStackTrace();
return false;
}
finally {//在这里释放事务资源
if(tx!=null) {
//tx.commit();不能重复提交
tx=null;
}
}
}
}
（4）写完之后可以在Test文件中创建一个serviceimpl的包，在里面创建一个类对写完的这个模块进行测试看是否有错误，这是为了防止最后出现很多的错误，解决起来麻烦。
package service.impl;
import org.junit.Test;
import entity.Users;
import junit.framework.Assert;
import service.UsersDAO;
public class TestUsersDAOImpl {
@Test
public void testUsersLogin() {
Users u=new Users(1,"zhangsan","123456");//提前在数据库添加了一行这个数据，
UsersDAO udao=new UsersDAOImpl();
Assert.assertEquals(true, udao.usersLogin(u));
}
}
（5）设计所有的Action父类
package Action;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.apache.struts2.util.ServletContextAware;
import com.opensymphony.xwork2.ActionSupport;
//所有Action的父类
public class SuperAction extends ActionSupport implements ServletRequestAware,ServletResponseAware,ServletContextAware {
/**
*
*/
private static final long serialVersionUID = 1L;
protected HttpServletRequest request;//请求对象
protected HttpServletResponse response;//响应对象
protected HttpSession session;//会话对象
protected ServletContext application;//全局对象
public void setServletContext(ServletContext application) {
this.application=application;
}
public void setServletResponse(HttpServletResponse response) {
this.response=response;
}
public void setServletRequest(HttpServletRequest request) {
this.request=request;
this.session=this.request.getSession();
}
}
（6）设计用户action类
package Action;
import com.opensymphony.xwork2.ModelDriven;
import entity.Users;
import service.UsersDAO;
import service.impl.UsersDAOImpl;
public class UsersAction extends SuperAction implements ModelDriven<Users> {
/**
*
*/
private static final long serialVersionUID = 1L;
private Users user=new Users();//用模型驱动需要这样写，可以不用写get，set方法。
//用户登录错误
public String login() {
UsersDAO udao=new UsersDAOImpl();
if(udao.usersLogin(user)) {//usersLogin的返回值是布尔值
return "login_success";//返回的是jsp页面。
}else {
return "login_failure";
}
}
public Users getModel() {
return this.user;
}
}
然后在struts.xml中配置：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<!-- 所有匹配*.action的请求都由struts2处理
<constant name="struts.action.extension" value="action" />
是否启用开发模式
<constant name="struts.devMode" value="true" />
struts配置文件改动后，是否重新加载
<constant name="struts.configuration.xml.reload" value="true" />
设置浏览器是否缓存静态内容
<constant name="struts.serve.static.browserCache" value="false" />
请求参数的编码方式
<constant name="struts.i18n.encoding" value="utf-8" />
每次HTTP请求系统都重新加载资源文件，有助于开发
<constant name="struts.i18n.reload" value="true" />
文件上传最大值
<constant name="struts.multipart.maxSize" value="104857600" />
让struts2支持动态方法调用
<constant name="struts.enable.DynamicMethodInvocation" value="true" />
Action名称中是否还是用斜线
<constant name="struts.enable.SlashesInActionNames" value="false" />
允许标签中使用表达式语法
<constant name="struts.tag.altSyntax" value="true" />
对于WebLogic,Orion,OC4J此属性应该设置成true
<constant name="struts.dispatcher.parametersWorkaround" value="false" /> -->
<package name="default" namespace="/" extends="struts-default">
</package>
<package name="users" namespace="/users" extends="default" >
<!-- method是Action中 方法，class是路径，{1}是第一个*，-->
<action name="*_*" class="action.{1}Action" method="{2}" >
<!-- name="login_success"表示在UsersAction类中的login方法中的返回的值，对应了/users/Users_login_success.jsp页面。-->
<result name="login_success">/users/Users_login_success.jsp</result>
<result name="login_failure">/users/Users_login.jsp</result>
</action>
</package>
</struts>
（7）用户的注销功能
package Action;
import com.opensymphony.xwork2.ModelDriven;
import entity.Users;
import service.UsersDAO;
import service.impl.UsersDAOImpl;
public class UsersAction extends SuperAction implements ModelDriven<Users> {
/**
*
*/
private static final long serialVersionUID = 1L;
private Users user=new Users();//用模型驱动需要这样写，可以不用写get，set方法。
//用户登录动作
public String login() {
UsersDAO udao=new UsersDAOImpl();
if(udao.usersLogin(user)) {//usersLogin的返回值是布尔值
//在session中保存登录成功的用户名,就是登录成功后，进行显示，在登录成功后的界面进行显示。
session.setAttribute("loginUserName", user.getUsername());
return "login_success";//返回的是jsp页面。
}else {
return "login_failure";
}
}
//用户的注销方法,然后去struts进行配置
public String logout() {
if(session.getAttribute("loginUserName")!=null) {
session.removeAttribute("loginUserName");
}
return "logout_success";
}
public Users getModel() {
return this.user;
}
}
<package name="users" namespace="/users" extends="default" >
<!-- method是Action中 方法，class是路径，{1}是第一个*，-->
<action name="*_*" class="action.{1}Action" method="{2}" >
<!-- name="login_success"表示在UsersAction类中的login方法中的返回的值，对应了/users/Users_login_success.jsp页面。-->
<result name="login_success">/users/Users_login_success.jsp</result>
<result name="login_failure">/users/Users_login.jsp</result>
<!-- 这是注销功能返回的界面，即返回到登录界面 -->
<result name="logout_success">/users/Users_login.jsp</result>
</action>
（8）表单验证功能
在UserAction中对ActionSupport重写验证表单
@Override
public void validate() {
//用户名不能为空
if("".equals(user.getUsername().trim())) {
this.addFieldError("usernameError", "用户名不能为空");
}
if(user.getPassword().length()<6) {
this.addFieldError("passwordError", "密码长度不少于6位");
}
}
在这里添加数据是为了进行一些测试，可以在测试类中实现将一些数据放到数据库中，
package entity;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;
public class TestStudents {
//@Test注解要写在你要测试的方法上面
//然后点击--运行方式,再点击Junit测试，就可以了。@Test的使用 是该方法可以不用main方法调用就可以测试出运行结果，是一种测试方法
//一般函数都需要有main方法调用才能执行
@Test
public void testSchemaExport() {//通过这个测试方法来生成表结构
//创建配置对象
Configuration config=new Configuration().configure();
//创建服务注册对象
ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
//创建sessionFactory
SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);
//创建session对象
Session session=sessionFactory.getCurrentSession();
//创建SchemaExport对象
SchemaExport export=new SchemaExport(config);
//生成表结构,第一个参数表示生成表结构，第二个参数表示输出sql语句
export.create(true,true);
}
//添加测试数据
@Test
public void testSaveStudents() {
//创建配置对象
Configuration config=new Configuration().configure();
//创建服务注册对象
ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
//创建sessionFactory
SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);
//创建session对象
Session session=sessionFactory.getCurrentSession();
//创建事务对象,并开启
Transaction tx=session.beginTransaction();
//添加数据
Students s1=new Students("s0000001","张三丰","男",new Date(),"武当山");
Students s2=new Students("s0000002","张三","男",new Date(),"华山");
Students s3=new Students("s0000003","张丰","男",new Date(),"黄山");
//保存
session.save(s1);
session.save(s2);
session.save(s3);
}
}
（1）设计学生业务逻辑接口以及实现类
package service;
import java.util.List;
import entity.Students;
//学生的业务逻辑接口
public interface StudentsDAO {
//查询所有学生资料
public List<Students> queryAllStudents();
//根据学生编号查询学生资料
public Students queryStudentsBySid(String sid);
//添加学生资料
public boolean addStudents(Students s);
//修改学生资料
public boolean updateStudents(Students s);
//删除学生资料
public boolean deleteStudents(String sid);
}
package service.impl;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import db.MyHibernateSessionFactory;
import entity.Students;
import service.StudentsDAO;
public class StudentsDAOImpl implements StudentsDAO {
//查询所有学生的资料
public List<Students> queryAllStudents() {
//事务对象
Transaction tx=null;
List<Students> list=null;
//hql的查询语句
String hql="";
try {
//用自己创建的MyHibernateSessionFactory获得一个会话对象
Session session=MyHibernateSessionFactory.getSessionFactory().getCurrentSession();
//开启事务
tx=session.beginTransaction();
//hql语句
hql="from Students";
/*
* createQuery与createSQLQuery两者区别是：
前者用的hql语句进行查询，后者可以用sql语句查询
前者以hibernate生成的Bean为对象装入list返回
后者则是以对象数组进行存储
*/
Query query=session.createQuery(hql);
list=query.list();
tx.commit();//返回之前提交
return list;
}catch(Exception ex) {
ex.printStackTrace();
tx.commit();
return list;
}
finally {//在这里释放事务资源
if(tx!=null) {
tx=null;
}
}
}
public Students queryStudentsBySid(String sid) {
// TODO Auto-generated method stub
return null;
}
public boolean addStudents(Students s) {
// TODO Auto-generated method stub
return false;
}
public boolean updateStudents(Students s) {
// TODO Auto-generated method stub
return false;
}
public boolean deleteStudents(String sid) {
// TODO Auto-generated method stub
return false;
}
}
还要进行测试看是否成功：
package service.impl;
import java.util.List;
import org.junit.Test;
import entity.Students;
import service.StudentsDAO;
public class TestStudentsDAOImpl {
//测试查询全部数据的代码是否正确。
@Test
public void testQueryAllStudents() {
StudentsDAO sdao=new StudentsDAOImpl();
List<Students> list=sdao.queryAllStudents();
for(int i=0;i<list.size();i++) {
System.out.println(list.get(i));//在Students中有重写toString
}
}
}
（2）实现显示学生资料的StudentsAction
package Action;
import java.util.List;
import entity.Students;
import service.StudentsDAO;
import service.impl.StudentsDAOImpl;
//学生Action类
public class StudentsAction extends SuperAction{
/**
*
*/
private static final long serialVersionUID = 1L;
//查询所有学生的动作，然后去struts.xml文件中配置StudentsAction。
public String query() {
StudentsDAO sdao=new StudentsDAOImpl();
List<Students> list=sdao.queryAllStudents();
//放进session中
if(list!=null&&list.size()>0) {
session.setAttribute("students_list", list);
}
return "Students_query_success";//返回一个jsp页面
}
}
然后配置struts.xml文件；