NETCTOSS项目（一）
项目分布结构：
一、dao包里面文件
package dao;
import entity.Admin;
public interface AdminDao {
Admin findByCode(String code);
}
package dao;
import java.util.List;
import entity.Cost;
public interface CostDao {
List findAll(); //资费查询功能
void save(Cost c); //增加资费功能
Cost findById(int id);
void update(Cost c); //修改资费
void startCost(int id); //启用资费
void deleteCost(int id); //删除资费
List findByPage(int page,int size);//分页查询
int findRows(); //查询数据的总行数
}
package dao;
import java.io.Serializable;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import entity.Admin;
import util.DBUtil2;
public class AdminDoaImpl implements AdminDao,Serializable {
public Admin findByCode(String code) {//根据帐号查找
try{
Connection conn = DBUtil2.getConnection();
String sql = "SELECT * FROM admin_info WHERE admin_code=?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, code);
ResultSet rs = ps.executeQuery();
if(rs.next()){//若账号存在,否则返回null
Admin a = createAdmin(rs);
return a;
}
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("查找管理员失败",e);
}finally{
DBUtil2.closeConnection();
}
return null;
}
//自动生成,供其他调用
private Admin createAdmin(ResultSet rs) throws SQLException {
Admin a = new Admin();
a.setAdminId(rs.getInt("admin_id"));
a.setAdminCode(rs.getString("admin_code"));
a.setPassword(rs.getString("password"));
a.setName(rs.getString("name"));
a.setTelephone(rs.getString("telephone"));
a.setEmail(rs.getString("email"));
a.setEnrolldate(rs.getTimestamp("enrolldate"));
return a;
}
public static void main(String[] args) {
AdminDoaImpl dao = new AdminDoaImpl();
Admin a = dao.findByCode("caocao");
if(a != null){
System.out.println(a.getAdminId());
System.out.println(a.getTelephone());
}else{
System.out.println(a);//null
}
}
}
package dao;
import java.io.Serializable;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import entity.Cost;
import util.DBUtil2;
public class CostDaoImpl implements CostDao, Serializable {
public List findAll() {
try{
Connection conn = DBUtil2.getConnection();
String sql = "SELECT * FROM cost ORDER BY cost_id";
Statement state = conn.createStatement();
ResultSet rs = state.executeQuery(sql);
List list = new ArrayList();
while(rs.next()){
Cost c = createCost(rs);//重构方法(封装)
list.add(c);
}
return list;
}catch(Exception e){
//实际情况要记录日志--Log4j工具
e.printStackTrace();
//抛出异常-由调用者处理
throw new RuntimeException("查询资费失败",e);
}finally{
DBUtil2.closeConnection();
}
}
/**
* Alt + Shift +M 提取方法的快捷键(先选中某代码片段)
*/
private Cost createCost(ResultSet rs) throws SQLException {
Cost c = new Cost();
c.setCostId(rs.getInt("cost_id"));
c.setName(rs.getString("name"));
c.setBaseDuration(rs.getInt("base_duration"));
c.setBaseCost(rs.getDouble("base_cost"));
c.setUnitCost(rs.getDouble("unit_cost"));
c.setStatus(rs.getString("status"));
c.setDescr(rs.getString("descr"));
c.setCreatime(rs.getTimestamp("creatime"));
c.setStartime(rs.getTimestamp("startime"));
c.setCostType(rs.getString("cost_type"));
return c;
}
//增加资费功能
public void save(Cost c) {
try{
Connection conn = DBUtil2.getConnection();
String sql = "INSERT INTO cost VALUES "
+ "(cost_seq.nextval,?,?,?,?,1,?,sysdate,null,?)";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, c.getName());
/***
* ps.setInt() ps.setDouble()只能传入基本类型,但在实际业务中确实有null,
* 而且数据库支持null,要用Object替换,当作对象来处理
*/
ps.setObject(2, c.getBaseDuration());
ps.setObject(3, c.getBaseCost());
ps.setObject(4, c.getUnitCost());
ps.setString(5, c.getDescr());
ps.setString(6, c.getCostType());
ps.executeUpdate();
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("增加员工失败",e);
}finally{
DBUtil2.closeConnection();
}
}
//测试dao
public static void main(String[] args) {
CostDao dao = new CostDaoImpl();
dao.deleteCost(203);
}
public Cost findById(int id) {
try{
Connection conn = DBUtil2.getConnection();
String sql = "SELECT * FROM cost WHERE cost_id=?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setInt(1, id);
ResultSet rs = ps.executeQuery();
Cost c = new Cost();
if(rs.next()){
return createCost(rs);
}
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("查询数据库失败",e);
}finally{
DBUtil2.closeConnection();
}
return null;//没有找到返回null
}
//修改资费
public void update(Cost c) {
try{
Connection conn = DBUtil2.getConnection();
String sql = "UPDATE cost SET "
+ "name=?,base_duration=?,base_cost=?,unit_cost=?,cost_type=?,descr=? "
+ "WHERE cost_id=?";
PreparedStatement ps = conn.prepareStatement(sql);
//从Cost中获取的该属性可能为null,所以ps中使用Object
ps.setString(1, c.getName());
ps.setObject(2, c.getBaseDuration());
ps.setObject(3, c.getBaseCost());
ps.setObject(4, c.getUnitCost());
ps.setString(5, c.getCostType());
ps.setString(6, c.getDescr());
ps.setObject(7, c.getCostId());
ps.executeUpdate();
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("修改数据库失败",e);
}finally{
DBUtil2.closeConnection();
}
}
public void startCost(int id) {
try{
Connection conn = new DBUtil2().getConnection();
String sql = "UPDATE cost SET status='0' WHERE cost_id=?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setInt(1, id);
ps.executeUpdate();
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("启用资费失败",e);
}finally{
DBUtil2.closeConnection();
}
}
public void deleteCost(int id) {
try{
Connection conn = DBUtil2.getConnection();
String sql = "DELETE FROM cost WHERE cost_id=?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setInt(1, id);
ps.executeUpdate();
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("删除资费失败",e);
}finally{
DBUtil2.closeConnection();
}
}
//分页查询
public List findByPage(int page, int size) {
try{
Connection conn = DBUtil2.getConnection();
String sql =
"SELECT * FROM("+
"SELECT ROWNUM rw,c.* FROM("+
"SELECT * FROM cost ORDER BY cost_id) c"+
") WHERE rw BETWEEN ? AND ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setInt(1, (page-1)*size+1);
ps.setInt(2, page*size);
ResultSet rs = ps.executeQuery();
List list = new ArrayList();
while(rs.next()){
Cost c = createCost(rs);
list.add(c);
}
return list;
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("分页查询失败",e);
}finally{
DBUtil2.closeConnection();
}
}
//查询总行数
public int findRows() {
try{
Connection conn = DBUtil2.getConnection();
String sql = "SELECT COUNT(*) c FROM cost";
Statement state = conn.createStatement();
ResultSet rs = state.executeQuery(sql);
if(rs.next()){
return rs.getInt(1);//return rs.getInt("c");
}
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("查询总行数失败", e);
}finally{
DBUtil2.closeConnection();
}
return 0;
}
}
package entity;
import java.io.Serializable;
import java.sql.Timestamp;
public class Admin implements Serializable {
private Integer adminId;
private String adminCode;
private String password;
private String name;
private String telephone;
private String email;
private Timestamp enrolldate;
public Admin(){}
public Integer getAdminId() {
return adminId;
}
public void setAdminId(Integer adminId) {
this.adminId = adminId;
}
public String getAdminCode() {
return adminCode;
}
public void setAdminCode(String adminCode) {
this.adminCode = adminCode;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Timestamp getEnrolldate() {
return enrolldate;
}
public void setEnrolldate(Timestamp enrolldate) {
this.enrolldate = enrolldate;
}
}
package entity;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* 一共10个字段
* java.sql.包下的日期类型:
* java.sql.Date 年月日
* java.sql.Time 时分秒
* java.sql.Timestamp 年月日时分秒且带有小数
*/
public class Cost implements Serializable {
//主键
private Integer costId;
//资费名称
private String name;
//基本时长
private Integer baseDuration;
//基本费用
private Double baseCost;
//单位费用
private Double unitCost;
//状态(数据库是char) 0-开通 1-暂停
private String status;
//描述
private String descr;
//创建时间
private Timestamp creatime;
//开通时间
private Timestamp startime;
//资费类型(数据库是char) 1-包月 2-套餐 3-计时
private String costType;
public Cost(){}
public Integer getCostId() {
return costId;
}
public void setCostId(Integer costId) {
this.costId = costId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getBaseDuration() {
return baseDuration;
}
public void setBaseDuration(Integer baseDuration) {
this.baseDuration = baseDuration;
}
public Double getBaseCost() {
return baseCost;
}
public void setBaseCost(Double baseCost) {
this.baseCost = baseCost;
}
public Double getUnitCost() {
return unitCost;
}
public void setUnitCost(Double unitCost) {
this.unitCost = unitCost;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getDescr() {
return descr;
}
public void setDescr(String descr) {
this.descr = descr;
}
public Timestamp getCreatime() {
return creatime;
}
public void setCreatime(Timestamp creatime) {
this.creatime = creatime;
}
public Timestamp getStartime() {
return startime;
}
public void setStartime(Timestamp startime) {
this.startime = startime;
}
public String getCostType() {
return costType;
}
public void setCostType(String costType) {
this.costType = costType;
}
}
package util;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import org.apache.commons.dbcp.BasicDataSource;
/**
* 使用连接池技术管理连接
*/
public class DBUtil2 {
// 数据库连接池
private static BasicDataSource ds;
// 为不同线程管理连接
private static ThreadLocal tl;
static {
Properties p = new Properties();
InputStream is = DBUtil2.class.getClassLoader().getResourceAsStream("config.properties");
try {
p.load(is);
is.close();
String driver = p.getProperty("driver").trim();
String url = p.getProperty("url").trim();
String user = p.getProperty("user").trim();
String password = p.getProperty("password").trim();
int initsize = Integer.parseInt((p.getProperty("initsize")));
int maxactive = Integer.parseInt(p.getProperty("maxactive"));
long maxwait = Integer.parseInt(p.getProperty("maxwait"));
// 初始化连接池
ds = new BasicDataSource();
// 设置驱动
ds.setDriverClassName(driver);
// 设置url
ds.setUrl(url);
// 设置数据库用户名
ds.setUsername(user);
// 设置数据库密码
ds.setPassword(password);
// 设置初始化连接数量
ds.setInitialSize(initsize);
// 设置连接池允许的最大连接数量
ds.setMaxActive(maxactive);
// 设置最大等待时间
ds.setMaxWait(maxwait);
//初始化线程本地
tl = new ThreadLocal();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("加载配置文件失败", e);
}
}
/**
* 通过连接池获取一个空闲连接
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
Connection conn = ds.getConnection();
tl.set(conn);
return conn;
}
/**
* 关闭数据库连接
*/
public static void closeConnection(){
try {
Connection conn = tl.get();
if(conn != null){
//恢复连接为自动提交事务
conn.setAutoCommit(true);
/**
* 通过连接池获取的此处的Connection的
* close()方法实际上并没有将连接关闭,
* 而是将该连接归还给连接池
*/
conn.close();
tl.remove();//将该连接从线程本地删除
}
} catch (SQLException e) {
e.printStackTrace();
}
}
//测试数据库连接正常
public static void main(String[] args) {
try {
Connection conn = DBUtil2.getConnection();
System.out.println(conn);
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBUtil2.closeConnection();
}
}
}
package util;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Random;
import javax.imageio.ImageIO;
public final class ImageUtil {
// 验证码字符集
private static final char[] chars = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
// 字符数量
private static final int SIZE = 4;
// 干扰线数量
private static final int LINES = 5;
// 宽度
private static final int WIDTH = 80;
// 高度
private static final int HEIGHT = 40;
// 字体大小
private static final int FONT_SIZE = 30;
/**
* 生成随机验证码及图片
*/
public static Object[] createImage() {
StringBuffer sb = new StringBuffer();
// 1.创建空白图片
BufferedImage image = new BufferedImage(
WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
// 2.获取图片画笔
Graphics graphic = image.getGraphics();
// 3.设置画笔颜色
graphic.setColor(Color.LIGHT_GRAY);
// 4.绘制矩形背景
graphic.fillRect(0, 0, WIDTH, HEIGHT);
// 5.画随机字符
Random ran = new Random();
for (int i = 0; i driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:orcl
user=scott
password=jsd161102
initsize=1
maxactive=1
maxwait=5000过滤器：
package web;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class LoginFilter implements Filter {
public void destroy() {
}
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
//从session中尝试获取帐号
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse)res;
//有三个请求不需要过滤,排除他们
String[] path = new String[]{"/toLogin.do","/login.do","/createImg.do"};
//当前路径
String sp = request.getServletPath();
//若当前路径是这三个路径之一,则不必过滤,请求继续执行
for(String s : path){
if(s.equals(sp)){
chain.doFilter(request, response);
return;
}
}
HttpSession session = request.getSession();
String adminCode = (String) session.getAttribute("adminCode");
//根据帐号判断是否已经登录
if(adminCode == null){
response.sendRedirect("/netctoss/toLogin.do");
}else{
chain.doFilter(request, response);//传入req,res都可以
}
}
public void init(FilterConfig arg0) throws ServletException {
}
}
package web;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.OutputStream;
import java.util.List;
import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import dao.AdminDoaImpl;
import dao.CostDao;
import dao.CostDaoImpl;
import entity.Admin;
import entity.Cost;
import util.ImageUtil;
public class MainServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//获取请求路径
String path = req.getServletPath();
//根据路径处理规范
if("/findCost.do".equals(path)){//查询资费
findCost(req,res);
}else if("/toAddCost.do".equals(path)){//打开增加资费页面
toAddCost(req,res);
}else if("/addCost.do".equals(path)){//增加资费
addCost(req,res);
}else if("/toUpdateCost.do".equals(path)){//打开修改资费页面
toUpdateCost(req,res);
}else if("/updateCost.do".equals(path)){ //修改资费
updateCost(req,res);
}else if("/toLogin.do".equals(path)){ //打开登录页面
toLogin(req,res);
}else if("/login.do".equals(path)){ //登录
login(req,res);
}else if("/toIndex.do".equals(path)){ //主页
toIndex(req,res);
}else if("/startCost.do".equals(path)){ //启用资费
startCost(req,res);
}else if("/deleteCost.do".equals(path)){ //删除资费
deleteCost(req,res);
}else if("/createImg.do".equals(path)){ //创建验证码图片
createImg(req,res);
}else if("/logout.do".equals(path)){ //退出登录
logout(req,res);
}else{
throw new RuntimeException("查无此页");
}
}
//退出登录 /logout.do
protected void logout(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//销毁session 重定向到登录页面
HttpSession session = req.getSession();
session.invalidate();
res.sendRedirect("toLogin.do");
}
//生成验证码 /createImg.do
protected void createImg(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//生成验证码及图片
Object[] obj = ImageUtil.createImage();
//将验证码存入sesssion
HttpSession session = req.getSession();
session.setAttribute("imgcode", obj[0]);//验证码
//将图片输出给浏览器
res.setContentType("image/png");
//获取输出流,该流由服务器自动创建,输出目标指向当前访问的浏览器
OutputStream os = res.getOutputStream();
BufferedImage image = (BufferedImage) obj[1];
ImageIO.write(image, "png", os);
os.close();
}
//删除资费 /deleteCost.do
protected void deleteCost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//获取参数--没有中文
int id = Integer.parseInt(req.getParameter("id"));
//处理业务
new CostDaoImpl().deleteCost(id);
//从定向到查询页面
res.sendRedirect("findCost.do");
}
//启用资费 /startCost.do
protected void startCost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//接受参数(由于没有中文,不用设置字符集)
int id = Integer.parseInt(req.getParameter("costId"));
//处理业务--修改状态
new CostDaoImpl().startCost(id);
//从定向到查询页面
res.sendRedirect("findCost.do");
}
//登录验证 /login.do 判断帐号密码
protected void login(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//接受参数(由于没有中文,不用设置字符集)
String adminCode = req.getParameter("adminCode");
String password = req.getParameter("password");
String code = req.getParameter("code");//接收验证码
HttpSession session = req.getSession();
String imgcode = (String)session.getAttribute("imgcode");
if(code == null || !code.equalsIgnoreCase(imgcode)){
req.setAttribute("error", "验证码错误");
req.getRequestDispatcher("WEB-INF/main/login.jsp").forward(req, res);
return;//后面不用再执行dao,新能更好
}
//帐号密码验证
Admin a = new AdminDoaImpl().findByCode(adminCode);
if(a == null){
//帐号错误,转发到登录页面
req.setAttribute("error", "账号错误");
req.getRequestDispatcher("WEB-INF/main/login.jsp").forward(req, res);
}else if(!a.getPassword().equals(password)){
//密码错误
req.setAttribute("error", "密码错误");
req.getRequestDispatcher("WEB-INF/main/login.jsp").forward(req, res);
}else{
//检查成功,将帐号存入cookie,供其他页面调用,然后从定向主页，
Cookie c = new Cookie("adminCode",adminCode);
res.addCookie(c);//发送给浏览器
//考虑是否有中文,是否需要存硬盘,是否需要改变有效路径
c.setPath(req.getContextPath());
//利用session存入账号
session.setAttribute("adminCode", adminCode);
//String url = res.encodeRedirectURL("toIndex.do");//禁用cookie后的重定向
res.sendRedirect("toIndex.do");
}
}
//打开登录页面 /toLogin.do
protected void toLogin(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
req.getRequestDispatcher("WEB-INF/main/login.jsp").forward(req, res);
}
//打开主页面 /toIndex.do
protected void toIndex(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
req.getRequestDispatcher("WEB-INF/main/index.jsp").forward(req, res);
}
//修改资费 /updateCost.do
protected void updateCost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//接收数据
req.setCharacterEncoding("utf-8");
String costId = req.getParameter("costId");
String name = req.getParameter("name");
String costType = req.getParameter("costType");
//baseDuration baseCost unitCost 根据业务要求时可能为""空字符串
String baseDuration = req.getParameter("baseDuration");
String baseCost = req.getParameter("baseCost");
String unitCost = req.getParameter("unitCost");
String descr = req.getParameter("descr");
//System.out.println("获取baseDuration:"+baseDuration); 该三个值可能为""
//System.out.println("获取baseCost:"+baseCost);
//System.out.println("获取unitCost:"+unitCost);
//给属性赋值的时候,若为空字符串就不赋值,让其等于默认值null
Cost c = new Cost();
c.setCostId(Integer.parseInt(costId));
c.setName(name);
c.setCostType(costType);
if(baseDuration != null && !baseDuration.equals("")){
c.setBaseDuration(new Integer(baseDuration));
}
if(baseCost != null && !baseCost.equals("")){
c.setBaseCost(new Double(baseCost));
}
if(unitCost != null && !unitCost.equals("")){
c.setUnitCost(new Double(unitCost));
}
c.setDescr(descr);
//System.out.println("实体baseDuration:"+c.getBaseDuration()); 该三个值可能为null
//System.out.println("实体baseCost:"+c.getBaseCost());
//System.out.println("实体unitCost:"+c.getUnitCost());
//处理业务
new CostDaoImpl().update(c);
//从定向
res.sendRedirect("findCost.do");
}
//打开修改资费页面 /toUpdateCost.do
protected void toUpdateCost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//接收参数(路径传参) location.href='toUpdateCost.do?id=${c.costId}';
int id = Integer.parseInt(req.getParameter("id"));
Cost cost = new CostDaoImpl().findById(id);
//转发
req.setAttribute("cost", cost);
req.getRequestDispatcher("WEB-INF/cost/update.jsp").forward(req, res);
}
//查询资费 /findCost.do
protected void findCost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
//获取请求参数
String page = req.getParameter("page");
if(page == null || page.equals("")){
page = "1";
}
//获取常量
String size = getServletContext().getInitParameter("size");
//查询资费(这一页的资费情况)
CostDao dao = new CostDaoImpl();
List list =
dao.findByPage(Integer.parseInt(page), Integer.parseInt(size));
//将查询的数据计算总行数
int rows = dao.findRows();
int total = rows/Integer.parseInt(size);//到总页数
if(rows%Integer.parseInt(size) != 0){//多了一页
total++;
}
//转发到jsp
req.setAttribute("costs", list);
req.setAttribute("total", total);
req.setAttribute("page", page);
//当前:/netctoss/findCost.do 目标:/netctoss/WEB-INF/cost/find.jsp
req.getRequestDispatcher("WEB-INF/cost/find.jsp").forward(req, res);
}
//打开增加资费页面 /toAddCost.do
protected void toAddCost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
req.getRequestDispatcher("WEB-INF/cost/add.jsp").forward(req, res);
}
//增加资费 /addCost.do
protected void addCost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
//获取请求参数
String name = req.getParameter("name");
String costType = req.getParameter("costType");
//baseDuration baseCost unitCost如没有输入则为空字符串,不用给该属性赋值,让其为null
String baseDuration = req.getParameter("baseDuration");
String baseCost = req.getParameter("baseCost");
String unitCost = req.getParameter("unitCost");
String descr = req.getParameter("descr");
Cost c = new Cost();
c.setName(name);
c.setCostType(costType);
//由于业务类型的不同可能该字段readonly,不能输入,获取道德String为""空字符串
if(baseDuration != null && !baseDuration.equals("")){
c.setBaseDuration(new Integer(baseDuration));
}
if(baseCost != null && !baseCost.equals("")){
c.setBaseCost(new Double(baseCost));
}
if(unitCost != null && !unitCost.equals("")){
c.setUnitCost(new Double(unitCost));
}
c.setDescr(descr);
CostDao dao = new CostDaoImpl();
dao.save(c);
//从定向到查询资费页面
res.sendRedirect("findCost.do");
}
}