web应用大型实验报告基于ssh的javaweb网站设计.doc

JAVA WEB 大型实验

教育科学与技术学院
Web应用大型实验报告

题 目 虚拟网上银行
专 业 计算机科学与技术（专升本）
班 级 计算机专升本2015（2）班
姓 名
任课教师 　

2016年 12 月
目录
一、 系统设计目标 3
二、 开发环境概述 3
三、 系统需求说明 3
四、 使用框架简介 3
1.简介 3
2.Struts框架结构 4
3.Spring框架结构 5
4.hibernate框架结构 6
五、 软件结构图 7
六、 数据库设计 7
1. 用户表设计 7
2. 用户详细信息表设计 7
3. 账户状态表设计 8
4. 账单表设计 8
5. 账单类型表设计 8
6. 管理员表设计 8
7. 数据表关系图 8
七、 系统功能展示（附主要代码） 9
1. 目录结构示意 9
2. Status配置展示 9
3. Spring配置展示（部分） 10
4.整合Hibernate数据源配置 12
5.业务流程图展示（部分） 14
6.用户功能实现 14
7.用户逻辑业务实现 16
8.数据接口层 18
八、 前端界面功能设计 21
1. 相关框架 21
2. 账单 22
2.1可视化账单 25
2.2 下拉账单 25
3. 账单导出 26
九、 版本管理工具—TaoCode 28
十、 服务器管理 28
十一、 小结 28

一、 系统设计目标
本系统设计目的主要是模仿真实的网上银行体系，设计一个虚拟的网上银行系统。将真实的业务需求作为我们的开发前提。通过大型实验的方式，让我们对于java web的框架技术有个实际性的了解。在针对实际复杂的银行存储业务中，如何使用代码的方式，解决业务逻辑问题。同时扩宽对于新技术的了解和使用。如前端技术，后端主流框架技术，以及对于网络传输，数据库操作，服务器的维护等等。

二、 开发环境概述
后台服务器使用linux centos版本服务器，搭建Apache-tomcat环境。JDK为java 1.8版本。主要编程语言为Java，Html，Css，JavaScript。开发工具为intellij idea。Svn版本库为TaoCode。
三、 系统需求说明
虚拟网上银行的核心业务为存款，取款和转账。用户上需要区分普通用户和管理员用户。普通用户只能实现存取款以及转账，管理员用户不能存取款，也不能转账。管理员账户可以对所有开户的账号进行管理，冻结账户或者恢复账户。管理员拥有开通账户的权限，还能够查询所有用户。
四、 使用框架简介
1.简介
网上银行系统使用的主要框架为Status、hibernate和Spring。Struts对Model，View和Controller都提供了对应的组件。Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，可以应用在任何使用JDBC的场合，可以在Servlet/JSP的Web应用中使用，也可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
2.Struts框架结构　 

Struts对Model，View和Controller都提供了对应的组件。
在右图中，ActionServlet，这个类是Struts的核心控制器，负责拦截来自用户的请求。
Action，这个类通常由用户提供，该控制器负责接收来自ActionServlet的请求，并根据该请求调用模型的业务逻辑方法处理请求，并将处理结果返回给JSP页面显示。
2.Model部分　由ActionForm和JavaBean组成，其中ActionForm用于封装用户的请求参数，封装成ActionForm对象，该对象被ActionServlet转发给Action，Action根据ActionForm里面的请求参数处理用户的请求。
JavaBean则封装了底层的业务逻辑，包括数据库访问等。
3.View部分　该部分采用JSP实现。
Struts提供了丰富的标签库，通过标签库可以减少脚本的使用，自定义的标签库可以实现与Model的有效交互，并增加了现实功能。对应上图的JSP部分。
4.Controller组件　Controller组件有两个部分组成——系统核心控制器，业务逻辑控制器。
系统核心控制器，对应上图的ActionServlet。该控制器由Struts框架提供，继承HttpServlet类，因此可以配置成标注的Servlet。该控制器负责拦截所有的HTTP请求，然后根据用户请求决定是否要转给业务逻辑控制器。
业务逻辑控制器，负责处理用户请求，本身不具备处理能力，而是调用Model来完成处理。对应Action部分。
3.Spring框架结构
1.简介
◆目的：解决企业应用开发的复杂性
◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
◆范围：任何Java应用
简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
2.轻量　从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
3.控制反转　Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
4.面向切面　Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
5.容器　Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
6.框架　Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
4.hibernate框架结构
　Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
Hibernate的核心接口一共有5个，分别为:Session、SessionFactory、Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。下面对这五个核心接口分别加以介绍。
1.Session接口　Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSesion对象称为用户session。
2.SessionFactory接口　SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
3.Configuration接口　Configuration接口负责配置并启动Hibernate，创建SessionFactory对象。在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory对象。
4.Transaction接口　Transaction接口负责事务相关的操作。它是可选的，开发人员也可以设计编写自己的底层事务处理代码。
5.Query和Criteria接口　Query和Criteria接口负责执行各种数据库查询。它可以使用HQL语言或SQL语句两种表达方式。
五、 软件结构图

六、 数据库设计
1. 用户表设计

2. 用户详细信息表设计

3. 账户状态表设计

4. 账单表设计

5. 账单类型表设计

6. 管理员表设计

7. 数据表关系图

七、 系统功能展示（附主要代码）
1. 目录结构示意

l Action ->具体实现方法
l Biz ->业务逻辑类
l Dao ->数据接口层
l Entity -> 数据实例类
l Utils -> 使用工具类

2. Status配置展示

3. Spring配置展示（部分）
Spring主要配置整体项目的事务管理系统，AOP切面定义，以及消息通知。Spring作为IOC容器，拥有非常好的控制反转机制。我们可以通过spring的注入方式，将对象的实例生成转交给spring去管理，减少代码的复杂性和提高复用性。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
<!--声明事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!--定义事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!--定义一个切面-->
<aop:config>
<aop:pointcut id="transactionPointcut" expression="execution(* com.biz.impl.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<!--基于Annotation方式的事务管理配置-->
<tx:annotation-driven transaction-manager="transactionManager"/>
4.整合Hibernate数据源配置
在这个过程中，我们通过spring接管hibernate。将数据源配置成为一个单独的bean置于spring容器中。 在以往的JDBCTemplate中事务提交成功，异常处理都是通过Try/Catch 来完成，而在Spring中。Spring容器集成了TransactionTemplate，她封装了所有对事务处理的功能，包括异常时事务回滚，操作成功时数据提交等复杂业务功能。这都是由Spring容器来管理，大大减少了程序员的代码量，也对事务有了很好的管理控制。Hibernate中也有对事务的管理，hibernate中事务管理是通过SessionFactory创建和维护Session来完成。而Spring对SessionFactory配置也进行了整合，不需要在通过hibernate.cfg.xml来对
SessionaFactory进行设定。。Spring对事务有很好的封装，自己有一套事务管理的封装，使业务逻辑与事务管理分离，进一步达到解耦作用。
这样的话就可以很好的利用Sping对事务管理强大功能。避免了每次对数据操作都要现获得Session实例来启动事务/提交/回滚事务还有繁琐的Try/Catch操作。这些也就是Spring中的AOP（面向切面编程）机制很好的应用。一方面使开发业务逻辑更清晰、专业分工更加容易进行。另一方面就是应用Spirng  AOP隔离降低了程序的耦合性使我们可以在不同的应用中将各个切面结合起来使用大大提高了代码重用度。
<!--数据源-->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"
value="com.mysql.jdbc.Driver">
</property>
<property name="url" value="jdbc:mysql://localhost:3306/bank?useUnicode=true&amp;characterEncoding=UTF-8">
</property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>
com/dao/AccountEntity.hbm.xml
</value>
<value>com/dao/AdminEntity.hbm.xml</value>
<value>com/dao/PersoninfoEntity.hbm.xml</value>
<value>com/dao/StatusEntity.hbm.xml</value>
<value>com/dao/TransactionLogEntity.hbm.xml</value>
<value>com/dao/TransactionTypeEntity.hbm.xml</value>
</list>
</property>
</bean>

5.业务流程图展示（部分）

6.用户功能实现

package com.action;

import com.biz.UserBiz;
import com.dao.AccountEntity;
import com.dao.Password;
import com.dao.PersoninfoEntity;

import org.apache.struts2.interceptor.RequestAware;
import org.apache.struts2.interceptor.SessionAware;
import com.opensymphony.xwork2.ActionSupport;

import javax.annotation.Resource;
import java.util.Map;

/**
* Created by 38909 on 2016/10/6.
*/
public class UserAction extends ActionSupport implements RequestAware, SessionAware {

//定义通过@resource 注解注入的属性userBiz ，可省略set方法
@Resource
private UserBiz userBiz;

public void setUserBiz(UserBiz userBiz) {
this.userBiz = userBiz;
}
Map<String, Object> request;
Map<String, Object> session;
private AccountEntity account;
private PersoninfoEntity personinfo;
private Password pwd;
//退出登陆，销毁hibernate中的session缓存
public String logout(){
session.remove("account");
session.remove("personinfo");
return "success";
}
//登陆验证方法
public void validateLogin() {
super.validate();
AccountEntity a = userBiz.getAccount(account.getUsername());
if (a == null) {
this.addFieldError("username", "用户名不存在!!!");
} else {
if (!account.getPassword().equals(a.getPassword())) {
this.addFieldError("password", "密码不正确");
}
}
account = a;
}
//用户登录方法
public String login() {
personinfo = (PersoninfoEntity) account.getPersoninfos().iterator().next();
session.put("account", account);
session.put("personinfos", personinfo);
return SUCCESS;
}
7.用户逻辑业务实现
package com.biz.impl;
import com.biz.UserBiz;
import com.dao.AccountEntity;
import com.dao.AdminEntity;
import com.dao.StatusEntity;
import com.entity.UserDao;
import org.springframework.transaction.annotation.Transactional;
/**
* Created by 38909 on 2016/10/6.
*/
public class UserBizImpl implements UserBiz{
UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
//get 账户
@Override
public AccountEntity getAccount(String username) {
return userDao.getAccount(username);
}
@Override
public boolean modifyAccount(AccountEntity account) {
return userDao.updateAccount(account);
}
public void reflush(AccountEntity account) {
userDao.reflush(account);
}
@Override
@Transactional(readOnly = true)
public AccountEntity getAccount(int accountid) {
return userDao.getAccount(accountid);
}
@Override
public AdminEntity getAdmin(String username) {
return userDao.getAdmin(username);
}
@Override
public boolean modifyAdmin(AdminEntity admin) {
return userDao.modifyAdmin(admin);
}
//启用账户
@Override
public void enable(int id) {
//更据账户编号获取账户对象
AccountEntity account = userDao.getAccount(id);
//修改账户对象的状态属性，设置为启用
StatusEntity status = userDao.getStatus("启用");
account.setStatus(status);
//更新账户
userDao.updateAccount(account);
}
//冻结账户
@Override
public void locking(int id) {
AccountEntity account = userDao.getAccount(id);
StatusEntity status = userDao.getStatus("冻结");
account.setStatus(status);
userDao.updateAccount(account);
}
@Override
public boolean delAccount(int id) {
AccountEntity account = userDao.getAccount(id);
return userDao.delAccount(account);
}
@Override
public boolean addAccount(AccountEntity account) {
StatusEntity status = userDao.getStatus("启用");
account.setStatus(status);
return userDao.addAccount(account);
}
}
8.数据接口层
package com.entity.impl;
import com.dao.AccountEntity;
import com.dao.AdminEntity;
import com.dao.StatusEntity;
import com.entity.UserDao;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate4.support.HibernateDaoSupport;
/**
* Created by 38909 on 2016/10/6.
*/
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
@Override
public AccountEntity getAccount(String username) {
String hql = "from AccountEntity as a where a.username=:username";
Session session = this.getSessionFactory().getCurrentSession();
Query query = session.createQuery(hql);
query.setString("username",username);
return (AccountEntity)query.uniqueResult();
}
@Override
public boolean updateAccount(AccountEntity account) {
super.getHibernateTemplate().merge(account);
return true;
}
@Override
public StatusEntity getStatus(String name) {
String hql = "from StatusEntity as s where s.name =:name";
Session session = this.getSessionFactory().getCurrentSession();
Query query = session.createQuery(hql);
query.setString("name",name);
return (StatusEntity) query.uniqueResult();
}
@Override
public StatusEntity getStatus(int id) {
String hql = "from StatusEntity as s where s.id = :id";
Session session = this.getSessionFactory().getCurrentSession();
Query query = session.createQuery(hql);
query.setInteger("id",id);
return (StatusEntity) query.uniqueResult();
}
@Override
public void reflush(AccountEntity account){
super.getHibernateTemplate().refresh(account);
}
@Override
public AccountEntity getAccount(int accountid) {
return (AccountEntity) super.getHibernateTemplate().get(AccountEntity.class,accountid);
}

@Override
public AdminEntity getAdmin(String username) {
String hql = "from AdminEntity as a where a.username =:username";
Session session = this.getSessionFactory().getCurrentSession();
Query query = session.createQuery(hql);
query.setString("username",username);
return (AdminEntity) query.uniqueResult();
}
@Override
public boolean modifyAdmin(AdminEntity admin) {
super.getHibernateTemplate().update(admin);
return true;
}

@Override
public boolean delAccoun