大学生就业管理系统详细设计说明书2

大学生就业管理系统详细设计说明书2 《大学生就业管理》
详细设计说明书
1
1 引言
1.1 编写目的
本详细设计说明书跟据《博客信息管理系统详细设计说明书》编写，描述了系统的详细设计,并为系统代码的编写提供依据。

本文档的预期读者为:项目经理、系统分析员、测试经理、项目组长、系统开发人员。

1.2 系统命名与版本《大学生就业管理系统java命名规范》
大学生就业管理系统V1.0
1.3 定义
1.4 参考资料
《博客信息管理系统概要设计说明书》。

2 系统程序的结构
3 设计说明
3.1 数据库基本操作
3.1.1 类DB.java的设计方法名称:ExportDB(DataSource ds)
语义
由DataSource数据源ds获取Connection连接对象conn 方法名称:ResultSet openSql(String sql)
语义
由Connection连接对象conn获取Statement对象stmt;
由Statement对象stmt执行sql查询
返回ResultSet查询结果
方法名称:ResultSet execSql(String sql)
语义
由Connection连接对象conn获取Statement对象stmt;
2
由Statement对象stmt执行sql数据更新操作(包括新增、修改)
返回ResultSet数据更新操作结果
3.2 技能维护
3.2.1 类HibernateDao.java的设计 /**
* Copyright (c) 2005-2009
*
* Licensed under the Apache License, Version 2.0 (the "License");
*
* $Id: HibernateDao.java 441 2009-09-07 15:47:34Z calvinxiu $
*/
package com.zds.spring.dao.base;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import ng.StringUtils; import
org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SessionFactory; import
org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion; import
org.hibernate.criterion.Disjunction; import
org.hibernate.criterion.MatchMode; import org.hibernate.criterion.Order; import org.hibernate.criterion.Projection; import
org.hibernate.criterion.Projections; import
org.hibernate.criterion.Restrictions; import
org.hibernate.impl.CriteriaImpl;
3
import org.hibernate.transform.ResultTransformer; import
org.springframework.util.Assert; import
org.springside.modules.orm.PropertyFilter; import
org.springside.modules.orm.PropertyFilter.MatchType;
import org.springside.modules.utils.ReflectionUtils;
import mon.page.Page; //import
mon.page.PropertyFilter;
//import mon.page.PropertyFilter.MatchType;
/**
* 封装SpringSide扩展功能的Hibernat DAO泛型基类.
*
* 扩展功能包括分页查询,按属性过滤条件列表查询.
* 可在Service层直接使用,也可以扩展泛型DAO子类使用,见两个构造函数的注释.
*
* @param <T> DAO操作的对象类型
* @param <PK> 主键类型
*
* @author calvin
*/
public class HibernateDao<T, PK extends Serializable> extends SimpleHibernateDao<T, PK> {
/**
* 用于Dao层子类使用的构造函数.
* 通过子类的泛型定义取得对象类型Class.
* eg.
* public class UserDao extends HibernateDao<User, Long>{
* }
4
*/
public HibernateDao() {
super();
}
/**
* 用于省略Dao层, Service层直接使用通用HibernateDao的构造函数.
* 在构造函数中定义对象类型Class.
* eg.
* HibernateDao<User, Long> userDao = new HibernateDao<User,
Long>(sessionFactory, User.class);
*/
public HibernateDao(final SessionFactory sessionFactory, final Class<T> entityClass) {
super(sessionFactory, entityClass);
}
// 分页查询函数 //
/**
* 分页获取全部对象.
*/
public Page<T> getAll(final Page<T> page) {
return findPage(page);
}
/**
* 按HQL分页查询.
5
*
* @param page 分页参数.不支持其中的orderBy参数.
* @param hql hql语句.
* @param values 数量可变的查询参数,按顺序绑定.
*
* @return 分页查询结果, 附带结果列表及所有查询时的参数.
*/
@SuppressWarnings("unchecked")
public Page<T> findPage(final Page<T> page, final String hql, final Object... values) {
Assert.notNull(page, "page不能为空");
Query q = createQuery(hql, values);
if (page.isAutoCount()) {
long totalCount = countHqlResult(hql, values);
page.setTotalCount(totalCount);
}
setPageParameter(q, page);
List result = q.list();
page.setResult(result);
return page;
}
/**
* 按HQL分页查询.
*
* @param page 分页参数.
* @param hql hql语句.
6
* @param values 命名参数,按名称绑定.
*
* @return 分页查询结果, 附带结果列表及所有查询时的参数.
*/
@SuppressWarnings("unchecked")
public Page<T> findPage(final Page<T> page, final String hql, final Map<String, Object> values) {
Assert.notNull(page, "page不能为空");
Query q = createQuery(hql, values);
if (page.isAutoCount()) {
long totalCount = countHqlResult(hql, values);
page.setTotalCount(totalCount);
}
setPageParameter(q, page);
List result = q.list();
page.setResult(result);
return page;
}
/**
* 按Criteria分页查询.
*
* @param page 分页参数.
* @param criterions 数量可变的Criterion.
*
* @return 分页查询结果.附带结果列表及所有查询时的参数.
7
*/
@SuppressWarnings("unchecked")
public Page<T> findPage(final Page<T> page, final Criterion... criterions) {
Assert.notNull(page, "page不能为空");
Criteria c = createCriteria(criterions);
if (page.isAutoCount()) {
int totalCount = countCriteriaResult(c);
page.setTotalCount(totalCount);
}
setPageParameter(c, page);
List result = c.list();
page.setResult(result);
return page;
}
/**
* 设置分页参数到Query对象,辅助函数.
*/
protected Query setPageParameter(final Query q, final Page<T> page) {
//hibernate的firstResult的序号从0开始
q.setFirstResult(page.getFirst() - 1);
q.setMaxResults(page.getPageSize());
return q;
}
8
/**
* 设置分页参数到Criteria对象,辅助函数.
*/
protected Criteria setPageParameter(final Criteria c, final Page<T> page) {
//hibernate的firstResult的序号从0开始
c.setFirstResult(page.getFirst() - 1);
c.setMaxResults(page.getPageSize());
if (page.isOrderBySetted()) {
String[] orderByArray =
StringUtils.split(page.getOrderBy(), ',');
String[] orderArray = StringUtils.split(page.getOrder(), ',');
Assert.isTrue(orderByArray.length == orderArray.length, "分页多重排序参数中,排序字段与排序方向的个数不相等");
for (int i = 0; i < orderByArray.length; i++) {
if (Page.ASC.equals(orderArray[i])) {
c.addOrder(Order.asc(orderByArray[i]));
} else {
c.addOrder(Order.desc(orderByArray[i]));
}
}
}
return c;
}
/**
* 执行count查询获得本次Hql查询所能获得的对象总数.
9
*
* 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
*/
protected long countHqlResult(final String hql, final Object... values) {
Long count = 0L;
String fromHql = hql;
//select子句与order by子句会影响count查询,进行简单的排除.
fromHql = "from " + StringUtils.substringAfter(fromHql, "from");
fromHql = StringUtils.substringBefore(fromHql, "order by");
String countHql = "select count(*) " + fromHql;
try {
count = findUnique(countHql, values);
} catch (Exception e) {
throw new RuntimeException("hql can't be auto count, hql
is:" + countHql, e);
}
return count;
}
/**
* 执行count查询获得本次Hql查询所能获得的对象总数.
*
* 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
*/
protected long countHqlResult(final String hql, final Map<String, Object> values) {
Long count = 0L;
10
String fromHql = hql;
//select子句与order by子句会影响count查询,进行简单的排除.
fromHql = "from " + StringUtils.substringAfter(fromHql, "from");
fromHql = StringUtils.substringBefore(fromHql, "order by");
String countHql = "select count(*) " + fromHql;
try {
count = findUnique(countHql, values);
} catch (Exception e) {
throw new RuntimeException("hql can't be auto count, hql
is:" + countHql, e);
}
return count;
}
/**
count查询获得本次Criteria查询所能获得的对象总数. * 执行
*/
@SuppressWarnings("unchecked")
protected int countCriteriaResult(final Criteria c) {
CriteriaImpl impl = (CriteriaImpl) c;
// 先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执
行Count操作
Projection projection = impl.getProjection();
ResultTransformer transformer = impl.getResultTransformer();
List<CriteriaImpl.OrderEntry> orderEntries = null;
try {
orderEntries = (List) ReflectionUtils.getFieldValue(impl, "orderEntries");
ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayList());
11
} catch (Exception e) {
logger.error("不可能抛出的异常:{}", e.getMessage());
}
// 执行Count查询
int totalCount = (Integer)
c.setProjection(Projections.rowCount()).uniqueResult();
// 将之前的Projection,ResultTransformer和OrderBy条件重新设回去
c.setProjection(projection);
if (projection == null) {
c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
}
if (transformer != null) {
c.setResultTransformer(transformer);
}
try {
ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
} catch (Exception e) {
logger.error("不可能抛出的异常:{}", e.getMessage());
}
return totalCount;
}
// 属性过滤条件查询函数 //
/**
* 按属性查找对象列表,支持多种匹配方式.
*
* @param matchType 匹配方式,目前支持的取值见PropertyFilter的MatcheType enum.
*/
public List<T> findBy(final String propertyName, final Object
12
value, final MatchType matchType) {
Criterion criterion =
buildPropertyFilterCriterion(propertyName, value, value.getClass(), matchType);
return find(criterion);
}
/**
* 按属性过滤条件列表查找对象列表.
*/
public List<T> find(List<PropertyFilter> filters) {
Criterion[] criterions =
buildPropertyFilterCriterions(filters);
return find(criterions);
}
/**
* 按属性过滤条件列表分页查找对象.
*/
public Page<T> findPage(final Page<T> page, final
List<PropertyFilter> filters) {
Criterion[] criterions =
buildPropertyFilterCriterions(filters);
return findPage(page, criterions);
}
/**
* 按属性条件列表创建Criterion数组,辅助函数.
*/
protected Criterion[] buildPropertyFilterCriterions(final List<PropertyFilter> filters) {
List<Criterion> criterionList = new ArrayList<Criterion>();
for (PropertyFilter filter : filters) {
13
if (!filter.isMultiProperty()) { //只有一个属性需要比较的情况.
Criterion criterion =
buildPropertyFilterCriterion(filter.getPropertyName(),
filter.getPropertyValue(),
filter.getPropertyType(),
filter.getMatchType());
criterionList.add(criterion);
} else {//包含多个属性需要比较的情况,进行or处理.
Disjunction disjunction = Restrictions.disjunction();
for (String param : filter.getPropertyNames()) {
Criterion criterion =
buildPropertyFilterCriterion(param, filter.getPropertyValue(),
filter.getPropertyType(), filter.getMatchType());
disjunction.add(criterion);
}
criterionList.add(disjunction);
}
}
Return criterionList.toArray(new Criterion[criterionList.size()]);
}
/**
* 按属性条件参数创建Criterion,辅助函数.
*/
protected Criterion buildPropertyFilterCriterion(final String propertyName, final Object propertyValue,
final Class<?> propertyType, final MatchType matchType) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = null;
try {
14
//按entity property中的类型将字符串转化为实际类型.
Object realValue =
ReflectionUtils.convertValue(propertyValue, propertyType);
//根据MatchType构造criterion
if (MatchType.EQ.equals(matchType)) {
criterion = Restrictions.eq(propertyName, realValue);
}
if (MatchType.LIKE.equals(matchType)) {
criterion = Restrictions.like(propertyName, (String) realValue, MatchMode.ANYWHERE);
}
if (MatchType.LE.equals(matchType)) {
criterion = Restrictions.le(propertyName, realValue);
}
if (MatchType.LT.equals(matchType)) {
criterion = Restrictions.lt(propertyName, realValue);
}
if (MatchType.GE.equals(matchType)) {
criterion = Restrictions.ge(propertyName, realValue);
}
if (MatchType.GT.equals(matchType)) {
criterion = Restrictions.gt(propertyName, realValue);
}
} catch (Exception e) {
throw ReflectionUtils.convertToUncheckedException(e);
}
return criterion;
}
/**
* 判断对象的属性值在数据库内是否唯一.
15
*
* 在修改对象的情景下,如果属性新修改的值(value)等于属性原来的值(orgValue)则不作比较.
*/
public boolean isPropertyUnique(final String propertyName, final Object newValue, final Object oldValue) {
if (newValue == null || newValue.equals(oldValue))
return true;
Object object = findUniqueBy(propertyName, newValue);
return (object == null);
}
}
3.2.2 类SimpleHibernateDao.java的
设计
类SkillAction用来根据用户的不同操作，调用不同的方法对数据库进行操作。

方法
方法名称:doList ()
语法
package com.zds.spring.dao.base;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.LinkedHashSet;
函数原型 import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
16
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification; import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions; import
org.hibernate.metadata.ClassMetadata; import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;
Import
org.springframework.beans.factory.annotation.Autowired; import org.springside.modules.utils.ReflectionUtils; /**
* 封装Hibernate原生API的DAO泛型基类.
* 可在Service层直接使用,也可以扩展泛型DAO子类使用.
* 参考Spring2.5自带的Petlinc例子,取消了HibernateTemplate, 直接使用Hibernate原生API.
* @param <T> DAO操作的对象类型
* @param <PK> 主键类型
* @author calvin
*/
@SuppressWarnings("unchecked")
public class SimpleHibernateDao<T, PK extends Serializable> { protected Logger logger = LoggerFactory.getLogger(getClass());
protected SessionFactory sessionFactory;
17
protected Class<T> entityClass;
/**
* 用于Dao层子类使用的构造函数.
* 通过子类的泛型定义取得对象类型Class.
*/
public SimpleHibernateDao() {
this.entityClass =
ReflectionUtils.getSuperClassGenricType(getClass());
}
/**
* 用于用于省略Dao层, 在Service层直接使用通用SimpleHibernateDao的构造函数.
* 在构造函数中定义对象类型Class.
*/
public SimpleHibernateDao(final SessionFactory
sessionFactory, final Class<T> entityClass) {
this.sessionFactory = sessionFactory;
this.entityClass = entityClass;
}
public SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* 采用@Autowired按类型注入SessionFactory,当有多个SesionFactory的时候Override本函数.
*/
@Autowired
public void setSessionFactory(final SessionFactory sessionFactory) {
18
this.sessionFactory = sessionFactory;
}
/**
* 取得当前Session.
*/
public Session getSession() {
return sessionFactory.getCurrentSession();
}
/**
* 保存新增或修改的对象.
*/
public void saveOrUpdate(final T entity) { Assert.notNull(entity, "entity不能为空"); getSession().saveOrUpdate(entity);
logger.debug("save entity: {}", entity);
}
public void save(final T entity) {
Assert.notNull(entity, "entity不能为空"); getSession().save(entity);
logger.debug("save entity: {}", entity);
}
public void update(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().update(entity);
logger.debug("update entity: {}", entity);
}
/**
* 删除对象.
*
19
* @param entity 对象必须是session中的对象或含id属性的transient对象.
*/
public void delete(final T entity) {
if(entity!=null)
{
getSession().delete(entity);
logger.debug("delete entity: {}", entity);
}
else
logger.debug("delete entity is null");
}
/**
* 按id删除对象.
*/
public void delete(final PK id) {
Assert.notNull(id, "id不能为空");
delete(get(id));
logger.debug("delete entity {},id is {}", entityClass.getSimpleName(), id);
}
/**
* 按id获取对象.
*/
public T load(final PK id) {
Assert.notNull(id, "id不能为空");
return (T) getSession().load(entityClass, id); }
/**
20
* 按id获取对象.
*/
public T get(final PK id) {
Assert.notNull(id, "id不能为空");
return (T) getSession().get(entityClass, id); }
/**
* 获取全部对象.
*/
public List<T> getAll() {
return find();
}
/**
* 按属性查找对象列表,匹配方式为相等.
*/
public List<T> findBy(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return find(criterion);
}
/**
* 按属性查找唯一对象,匹配方式为相等.
*/
public T findUniqueBy(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能为空
21
");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T)
createCriteria(criterion).uniqueResult();
}
/**
* 按id列表获取对象.
*/
public List<T> findByIds(List<PK> ids) {
return find(Restrictions.in(getIdName(), ids));
}
/**
* 按HQL查询对象列表.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public <X> List<X> find(final String hql, final Object... values) { return createQuery(hql, values).list();
}
/**
* 按HQL查询对象列表.
*
* @param values 命名参数,按名称绑定.
*/
public <X> List<X> find(final String hql, final Map<String, Object> values) {
return createQuery(hql, values).list();
22
}
/**
* 按HQL查询唯一对象.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public <X> X findUnique(final String hql, final Object... values) { return (X) createQuery(hql, values).uniqueResult();
}
/**
* 按HQL查询唯一对象.
*
* @param values 命名参数,按名称绑定.
*/
public <X> X findUnique(final String hql, final Map<String, Object> values) {
return (X) createQuery(hql, values).uniqueResult();
}
/**
* 执行HQL进行批量修改/删除操作.
*/
public int batchExecute(final String hql, final Object... values) { return createQuery(hql, values).executeUpdate();
}
/**
23
* 执行HQL进行批量修改/删除操作.
* @return 更新记录数.
*/
public int batchExecute(final String hql, final Map<String, Object> values) {
return createQuery(hql, values).executeUpdate();
}
/**
* 根据查询HQL与参数列表创建Query对象.
*
* 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数.
* @param values 数量可变的参数,按顺序绑定.
*/
public Query createQuery(final String queryString,
final Object... values) {
Assert.hasText(queryString, "queryString不能为空");
Query query =
getSession().createQuery(queryString);
if (values != null) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
}
return query;
}
/**
* 根据查询HQL与参数列表创建Query对象.
24
*
* @param values 命名参数,按名称绑定.
*/
public Query createQuery(final String queryString, final Map<String, Object> values) {
Assert.hasText(queryString, "queryString不能为空"); Query query =
getSession().createQuery(queryString);
if (values != null) {
query.setProperties(values);
}
return query;
}
/**
* 按Criteria查询对象列表.
*
* @param criterions 数量可变的Criterion.
*/
public List<T> find(final Criterion... criterions) {
return createCriteria(criterions).list();
}
/**
* 按Criteria查询唯一对象.
*
* @param criterions 数量可变的Criterion.
*/
public T findUnique(final Criterion... criterions) {
return (T)
25
createCriteria(criterions).uniqueResult();
}
/**
* 根据Criterion条件创建Criteria.
*
* 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数. *
* @param criterions 数量可变的Criterion.
*/
public Criteria createCriteria(final Criterion... criterions) { Criteria criteria =
getSession().createCriteria(entityClass);
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
/**
* 初始化对象.
* 使用load()方法得到的仅是对象Proxy, 在传到View层前需要进行初始化.
* 只初始化entity的直接属性,但不会初始化延迟加载的关联集合和属性.
* 如需初始化关联属性,可实现新的函数,执行:
* Hibernate.initialize(user.getRoles())，初始化User的直接属性和关联集合.
* Hibernate.initialize(user.getDescription())，初始
26
化User的直接属性和延迟加载的Description属性.
*/
public void initEntity(T entity) {
Hibernate.initialize(entity);
}
/**
* @see #initEntity(Object)
*/
public void initEntity(List<T> entityList) {
for (T entity : entityList) {
Hibernate.initialize(entity);
}
}
/**
* 为Query添加distinct transformer.
*/
public Query distinct(Query query) {
query.setResultTransformer(CriteriaSpecification.DI STINCT_ROOT_ENTITY);
return query;
}
/**
* 为Criteria添加distinct transformer.
*/
public Criteria distinct(Criteria criteria) {
criteria.setResultTransformer(CriteriaSpecification
.DISTINCT_ROOT_ENTITY);
27
return criteria;
}
/**
* 通过Set将不唯一的对象列表唯一化.
* 主要用于HQL/Criteria预加载关联集合形成重复记录,又不方便使用distinct查询语句时.
*/
public <X> List<X> distinct(List list) {
Set<X> set = new LinkedHashSet<X>(list);
return new ArrayList<X>(set);
}
/**
* 取得对象的主键名.
*/
public String getIdName() {
ClassMetadata meta =
getSessionFactory().getClassMetadata(entityClass);
return meta.getIdentifierPropertyName();
}
}
查询数据库中符合条件的关联关系数据，导向功能描述
ListSkillInfo.jsp
输入参数 errors;messAges;mapping;form;request;response 输出参数无返回值无
抛出异常无
28
3.3 学生信息管理
3.3.1 学生个人信息管理
3.3.1.1 功能描述
, 查询学生个人信息: 学生用户登录后，在学生管理模块中可查看
个人信息。

输入查询条件后，检索的信息出现在招聘信息详细列表里。

如果结果比较多，可以翻页显示。

3.3.1.2 主代码
public Student findByCode(String code) {
return studentDao.findBy("code",code).get(0);
}
//分页查询所有学生
public Page<Student> findStudents(Page<Student> pageStu, Student student) {
return studentDao.findStudents(pageStu, student);
}
//添加学生
public void saveStudent(Student student) {
studentDao.save(student);
}
//修改学生
public void updateStudent(Student student) {
studentDao.update(student);
}
//根据id查询学生
public Student findById(int id){
29
return studentDao.findById(id); }
3.3.2 查看班级信息 3.3.2.1 功能描述
, 查看班级信息
, 对班级信息进行增加
, 删除班级信息
3.3.2.2 主代码
public Page<Clazz> findClazz(Page<Clazz> pageClazz, Clazz clazz) { return clazzDao.findClazz(pageClazz, clazz);
}
public void saveClazz(Clazz clazz) {
clazzDao.save(clazz);
}
public void udateClazz(Clazz clazz) {
clazzDao.update(clazz);
}
public Clazz findByCode(int code){
return (Clazz)clazzDao.find("code",code).get(0);
}
public Clazz findById(int id){
return (Clazz)clazzDao.findById(id);
}
3.3.3 就业信息查询
3.3.3.1 功能描述
, 查看学生就业状态,是待业还是就业或者其他
30
3.3.3.2 主代码
public Page<Department> findAll(Page<Department> page,Department dep) {
StringBuffer hql=new StringBuffer("from Department where 1=1"); if (dep instanceof Department) {
if(dep.getDepId()>0) {
hql.append(" and depId=" + dep.getDepId());
}
}
hql.append(" order by id desc");
try {
Page<Department> p = findPage(page, hql.toString());
return p;
} catch(RuntimeException re) {
log.error("查询用户失败", re);
throw re;
}
}
3.4 学生档案管理
3.4.1 查看学生档案
3.4.1.1 Student.java
//根据code查询学生
public Student findByCode(String code) {
return studentDao.findBy("code",code).get(0);
}
//分页查询所有学生
31
public Page<Student> findStudents(Page<Student> pageStu, Student student) {
return studentDao.findStudents(pageStu, student);
}
//添加学生
public void saveStudent(Student student) {
studentDao.save(student);
}
//修改学生
public void updateStudent(Student student) {
studentDao.update(student);
}
//根据id查询学生
public Student findById(int id){
return studentDao.findById(id);
}
3.5 辅导员信息
3.5.1 查看教师信息
3.5.1.1 类Teacher.java的设计
public Page<Teacher> findClazz(Page<Teacher> pageTeacher, Teacher teacher) {
return clazzDao.findTeacher(pageTeacher, teacher);
}
public void saveTeacher(Teacher teacher) {
clazzDao.save(teacher);
}
32
public void udateClazz(Teacher teacher) {
TeacherDao.update(teacher);
}
public Teacher findByCode(int code){
return (Teacher)TeacherDao.find("code",code).get(0);
}
public Teacher findById(int id){
return (Teacher)TeacherDao.findById(id);
}
3.5.2 查看教师信息
private Logger log = Logger.getLogger(getClass());
public Page<Teacher> findTeachers(Page<Teacher> pageRe,Teacher teacher){
String hql="from Teacher as r where 1=1 ";
if(teacher!=null){
if((teacher.getStudent()!=null&&String.valueOf(teacher.getStudent()) .trim().length()>0)&&
(teacher.getStudent().getId()!=null&&String.valueOf(teacher.getStude nt().getId()).trim().length()>0)){
hql+="and
r.student.id='"+teacher.getStudent().getId()+"' ";
}
}
hql+="and r.state.id=2 order by r.id asc";
try {
Page<Teacher> page=findPage(pageRe,hql);
33
return page;
} catch(RuntimeException re) {
log.error("查询简历失败", re);
throw re;
}
}
3.5.3 发布通知公告
private Logger log = Logger.getLogger(getClass());
public Page<Resume> findResumes(Page<Resume> pageRe,Resume
resume){
String hql="from Resume as r where 1=1 ";
if(resume!=null){
if((resume.getStudent()!=null&&String.valueOf(resume.getStudent()).t rim().length()>0)&&
(resume.getStudent().getId()!=null&&String.valueOf(resume.getStudent ().getId()).trim().length()>0)){
hql+="and
r.student.id='"+resume.getStudent().getId()+"' ";
}
}
hql+="and r.state.id=2 order by r.id asc";
try {
Page<Resume> page=findPage(pageRe,hql);
return page;
} catch(RuntimeException re) {
log.error("查询简历失败", re);
34
throw re;
}
}
3.5.4 发布招聘信息
private DepDao depDao;
public void setDepDao(DepDao depDao) {
this.depDao = depDao;
}
public Page<Department> findAll(Page<Department> page,Department dep) {
return depDao.findAll(page, dep);
}
3.5.5 查看班级信息
public Page<Clazz> findClazz(Page<Clazz> pageClazz, Clazz clazz) { return clazzDao.findClazz(pageClazz, clazz);
}
public void saveClazz(Clazz clazz) {
clazzDao.save(clazz);
}
public void udateClazz(Clazz clazz) {
clazzDao.update(clazz);
}
public Clazz findByCode(int code){
return (Clazz)clazzDao.find("code",code).get(0);
}
public Clazz findById(int id){
return (Clazz)clazzDao.findById(id);
35
}
3.6 管理员
3.6.1 查看班级信息
3.6.1.1 方法名称:findPerbasic() findPerbasic为 Struts架构中用于处理个人基本信息查询的方法。

ActionServlet控制器根据Struts-Config.XML，把View端用户请求”findPerbasic”转发到控制类PerbasicAction.java，再调用业务逻辑类PerbasicService的静态findPerbasic方法，把从数据库取得的查询数据显示在招聘信息显示页面perbasic.jsp上。

语法
public string findPerbasic(){
函数原型
}
调用PerbasicService的findPerbasic方法，findPerbasic方法在调用功能描述 PerbasicDao调用的bsedao里面的get方法，在数据库perbasic表中查出符
合查询条件的个人基本信息，在个人基本信息显示页面perbasic.jsp显示入口系统主界面main.html
ActionForm RecruitInfoQueryForm
正常出口个人基本信息显示页面perbasic.jsp
错误出口 error.jsp
输入参数无
方法内错误
无
信息处理类
抛出异常无
语义
创建Perbasic、PerbasicService的对象perbasic、perbasicService; public string findPerbasic(){
调用PerbasicService的findPerbasic方法;
36
用对象perbasic接收，将数据存储在Perbasic中;
返回一个字符串(与struts配置文件跳转个人基本信息显示页面的name值相匹配)。

}
3.6.1.2 方法名称:updatePerbasic () updatePerbasic用于处理个人密码修改提交的方法。

ActionServlet控制器根据Struts-Config.XML，把View端用户请求”/updatePerbasic”转发到控制类PerbasicAction.java的updatePerbasic方法，updatePerbasic取得Perbasic的数据，再调用业务逻辑类PerbasicService 的updatePerbasic方法，修改后的数据写回到数据库perbasic表。

语法
public String updatePerbasic ()
函数原型 {
}
取得Perbasic的数据，再调用业务逻辑类PerbasicService的
preupdatePerbasic方法，preupdatePerbasic方法在调用PerbasicDao调用的bsedao里面的get方法查询出密码后返回到PerbasicAction判断原密码是功能描述否一样，如果一样则调用updatePerbasic方法，将Perbasic里的数据提交给
PerbasicService的updatePerbasic方法，updatedPerbasic方法在调用
PerbasicDao调用的bsedao里面定于pdate方法将修改后的数据写回到数据库Perbasic表。

入口个人管理密码修改页面updatePerbasic.jsp
ActionForm RecruitInfoForm
正常出口个人管理密码修改成功页面
错误出口 error.jsp
输入参数无
方法内错误
37
信息处理类
抛出异常无
语义
创建Perbasic、PerbasicService的对象perbasic、perbasicService;
public String updatePerbasic ()
{
通过页面传递过来的id查询符合的数据出来;
调用PerbasicService的preupdatePerbasic方法;
然后提取密码字段出来;
判断查询的密码与页面输入的原密码是否一致;
一致的话;将新密码注入给Perbasic;
则调用调用PerbasicService的updatePerbasic方法;
修改数据成功则返回字符串update(与struts配置文件跳转个人成功(与struts配置文件跳转个人成功页面的name值相匹配)页面的name值相匹配);
不一致或者修改数据库失败则返回字符串error(与struts配置文件跳转个人跳转失败页面的name值相匹配);
}
3.6.2 查看招聘信息
接口类，用于接收PerbasicDao的操作，传递PerbasicAction提供的参数。

public List<Perbasic> findPerbasic (Perbasic perbasic); 函数原型
public void updatePerbasic (Perbasic perbasic); 功能描述用于传递PerbasicAction的方法参数、接收PerbasicDao的处理结果。

入口PerbasicAction。