struts2与hibernate的学生信息管理（未完）

最新推荐文章于 2024-09-21 10:38:43 发布

安静点DGC

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量213

点赞数

分类专栏： java 文章标签： java

java 专栏收录该内容

61 篇文章 0 订阅

订阅专栏

（一）

（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;
	}

}

struts.xml

 <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文件；