首页手记 javaweb版本的答答租车系统（源代码二）

javaweb版本的答答租车系统（源代码二）

标签：

Java

上接javaweb版本的答答租车系统（源代码一）
这是商品数据库操作类CommodityDao

package com.david.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.david.Commodity;
/**
 * 商品数据库操作类
 * @author David
 */
public class CommodityDao {
    /**
     * 新增商品
     * @param Commodity 商品
     * @author David
     */
    public void savecommodity(Commodity commodity){
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入新增商品的sql语句
        String sql = "insert into car_commodity(name,rent,manned,cargo,owner) value (?,?,?,?,?)";
        try {
            //获取preparedStatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql语句的占位符参数进行动态赋值
            ps.setString(1, commodity.getName());
            ps.setInt(2, commodity.getRent());
            ps.setInt(3, commodity.getManned());
            ps.setInt(4, commodity.getCargo());
            ps.setString(5, commodity.getOwner());
            //执行更新操作
            ps.executeUpdate();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
    }
    /**
     * 判断车辆在数据库中是否重复
     * @param name 车名
     * @author David
     * @return 判断结果
     */
    public boolean commodityExist(String name){
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //根据指定车名查询车辆信息
        String sql = "select * from car_commodity where name=?";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql语句占位符参数进行动态赋值
            ps.setString(1, name);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //判断此结果集是否有效
            if(!rs.next()){
                //如果无效则证明此车辆没有重复
                return true;
            }
            // 释放此 ResultSet 对象的数据库和 JDBC 资源
            rs.close();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库
            ConnectSJK.closeConnection(conn);
        }
        return false;
    }

    /**
     * 查询商品
     * @author David
     * @return 查询到的商品集合
     */
    public List<Commodity> commodity(){
        //定义集合保存查询到的商品
        List<Commodity> commoditylist = new ArrayList<Commodity>();
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //查询所有已上架商品
        String sql = "select * from car_commodity";
        try {
            //获取preparedStatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //循环判断结果集是否有效
            while(rs.next()){
                //实例化一个用户对象
                Commodity commodity = new Commodity();
                //对用户对象进行赋值
                commodity.setId(rs.getInt("id"));
                commodity.setName(rs.getString("name"));
                commodity.setRent(rs.getInt("rent"));
                commodity.setManned(rs.getInt("manned"));
                commodity.setCargo(rs.getInt("cargo"));
                commodity.setOwner(rs.getString("owner"));
                //将结果添加到集合中
                commoditylist.add(commodity);
            }
            // 释放此 ResultSet 对象的数据库和 JDBC 资源
            rs.close();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
        return commoditylist;
    }
    /**
     * 根据id查商品属性生成账单
     * @param id 商品编号
     * @author David
     * @return 商品对象
     */
    public Commodity commodityBill(Integer id){
        //实例化一个商品对象
        Commodity commodity = new Commodity();
        //获取Connection对象
        Connection conn = ConnectSJK.getConnection();
        //根据id查商品属性
        String sql = "select * from car_commodity where id = ?";
        try {
            //获取preparedStatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql语句占位符参数进行动态赋值
            ps.setInt(1, id);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //判断结果集是否有效
            if(rs.next()){
                //对用户对象进行赋值
                commodity.setId(rs.getInt("id"));
                commodity.setName(rs.getString("name"));
                commodity.setRent(rs.getInt("rent"));
                commodity.setManned(rs.getInt("manned"));
                commodity.setCargo(rs.getInt("cargo"));
                commodity.setOwner(rs.getString("owner"));
            }
            // 释放此 ResultSet 对象的数据库和 JDBC 资源
            rs.close();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
        return commodity;
    }
}

这是账单数据库操作类BillDao

package com.david.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.david.Bill;
/**
 * 账单数据库操作类
 * @author David
 */
public class BillDao {
    /**
     * 新增账单
     * @param bill 账单对象
     * @author David
     */
    public void saveBill(Bill bill){
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入生成账单的SQL语句
        String sql = "insert into car_bill(userid,carid,quantity,totalrent,carstatus,ordernumber,cartime) value (?,?,?,?,?,?,?)";
        try {
            //获取preparedStatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql语句的占位符参数进行动态赋值 
            ps.setInt(1, bill.getUserid());
            ps.setInt(2, bill.getCarid());
            ps.setInt(3, bill.getQuantity());
            ps.setDouble(4, bill.getTotalrent());
            ps.setString(5, bill.getCarstatus());
            ps.setString(7, bill.getOrdernumber());
            ps.setString(6, bill.getCartime());
            //执行更新操作
            ps.executeUpdate();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
    }
    /**
     * 查询账单
     * @author David
     * @return 查询到的账单集合
     */
    public List<Bill> bill(){
        //定义集合保存查询到的商品
        List<Bill> billlist = new ArrayList<Bill>();
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //查询所有账单信息
        String sql = "select * from car_bill";
        try {
            //获取preparedStatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //循环判断结果集是否有效
            while(rs.next()){
                //实例化一个账单对象
                Bill bill = new Bill();
                //对账单对象进行赋值
                bill.setCarid(rs.getInt("carid"));
                bill.setQuantity(rs.getInt("quantity"));
                bill.setTotalrent(rs.getDouble("totalrent"));
                bill.setCarstatus(rs.getString("carstatus"));
                bill.setOrdernumber(rs.getString("ordernumber"));
                bill.setCartime(rs.getString("cartime"));
                //将结果添加到集合中
                billlist.add(bill);
            }
            // 释放此 ResultSet 对象的数据库和 JDBC 资源
            rs.close();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
        return billlist;
    }
    /**
     * 结账
     * @param bill 账单对象
     * @param ordernumber 账单编号
     * @author David
     * @return 查询到的租金集合
     */
    public List<Bill> billplease(int userid, String carstatus){
        //定义集合保存查询到的结账信息
        List<Bill> billlist = new ArrayList<Bill>();
        //连接数据库获取Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入查询需要结账的账单信息的SQL语句
        String sql = "select totalrent from car_bill where userid=? and carstatus=?";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql语句的占位符参数进行动态赋值 
            ps.setInt(1, userid);
            ps.setString(2, carstatus);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //循环判断结果集是否有效
            while(rs.next()){
                //实例化一个账单对象
                Bill bill = new Bill();
                //对账单对象进行赋值
                bill.setTotalrent(rs.getDouble("totalrent"));
                //将结果添加到集合中
                billlist.add(bill);
            }
            // 释放此 ResultSet 对象的数据库和 JDBC 资源
            rs.close();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
        return billlist;
    }

    /**
     * 根据编号查账单
     * @param ordernumber 账单编号
     * @author David
     * @return 账单对象
     */
    public Bill idBill(String ordernumber){
        //实例化一个用户对象
        Bill bill = new Bill();
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入查询用户的sql语句
        String sql = "select * from tb_user where ordernumber=?";
        try {
            //获取preparedStatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            // 对SQL语句的占位符参数进行动态赋 值
            ps.setString(1, ordernumber);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //判断结果集是否有效
            if(rs.next()){
                //对用户对象进行赋值
                bill.setCarid(rs.getInt("carid"));
                bill.setQuantity(rs.getInt("quantity"));
                bill.setTotalrent(rs.getDouble("totalrent"));
                bill.setCarstatus(rs.getString("carstatus"));
                bill.setCartime(rs.getString("cartime"));
            }
            // 释放此 ResultSet 对象的数据库和 JDBC 资源
            rs.close();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            // 关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
        return bill;
    }
    /**
     * 根据用户ID查个人账单
     */
    public List<Bill> personalbill(Integer userid){
        //实例化一个账单id
        List<Bill> billlist = new ArrayList<Bill>();
        //获取Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入查询账单的sql语句
        String sql = "select * from car_bill where userid=?";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对SQL占位符参数进行动态赋值
            ps.setInt(1, userid);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //判断结果集是否有效
            while(rs.next()){
                Bill bill = new Bill();
                //对用户对象进行赋值
                bill.setCarid(rs.getInt("carid"));
                bill.setQuantity(rs.getInt("quantity"));
                bill.setTotalrent(rs.getDouble("totalrent"));
                bill.setCarstatus(rs.getString("carstatus"));
                bill.setOrdernumber(rs.getString("ordernumber"));
                bill.setCartime(rs.getString("cartime"));
                //将查询到的结果添加到集合中
                billlist.add(bill);
            }
            // 释放此 ResultSet 对象的数据库和 JDBC 资源
            rs.close();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
        return billlist;
    }

    /**
     * 退租
     * @param bill 账单对象
     * @param ordernumber 账单编号
     * @author David
     */
    public void surrender(Bill bill,String ordernumber){
        //获取数据库连接Connection对象 
        Connection conn = ConnectSJK.getConnection();
        //插入修改租车状态的SQL语句
        String sql = "update car_bill set carstatus=? where ordernumber=?";
        try {
            //获取preparedStatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对账单对象进行赋值
            ps.setString(1, bill.getCarstatus());
            ps.setString(2, ordernumber);
            // 执行更新操作
            ps.executeUpdate();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
    }
}

这是账户数据库操作类AccountDao

package com.david.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import com.david.Account;
import com.david.User;
/**
 * 账户数据库操作类
 * @author David
 */
public class AccountDao {
    /**
     * 新增账户
     * @param account 账户
     * @author David
     */
    public void saveAccount(Account account){
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入新增账户的sql语句
        String sql = "insert into car_account(username,money,let_frequency,out_frequency) value(?,?,?,?)";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql占位符参数进行动态赋值
            ps.setInt(1, account.getUserid());
            ps.setDouble(4, account.getMoney());
            ps.setInt(2, account.getLet_frequency());
            ps.setInt(3, account.getOut_frequency());
            //执行更新操作
            ps.executeUpdate();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
    }
    /**
     * 更新账户余额
     * @param user 用户
     * @author David
     */
    public void updatemoney(User user,Account account){
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入修改数据的sql语句
        String sql = "update car_account set money=? where userid=?";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql占位符参数进行动态赋值
            ps.setDouble(1, account.getMoney());
            ps.setInt(2, user.getId());
            //执行更新操作
            ps.executeUpdate();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }

    }

    /**
     * 更新租车次数
     * @param user 用户
     * @author David
     */
    public void updatelet_frequency(User user , Account account){
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入修改数据的sql语句
        String sql = "update car_account set let_frequency=? where userid=?";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql占位符参数进行动态赋值
            ps.setInt(1, account.getLet_frequency());
            ps.setInt(2, user.getId());
            //执行更新操作
            ps.executeUpdate();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
    }

    /**
     * 更新出租次数
     * @param user 用户
     * @author David
     */
    public void updateout_frequency(User user,Account account){
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //插入修改数据的sql语句
        String sql = "update car_account set out_frequency=? where userid=?";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对sql占位符参数进行动态赋值
            ps.setInt(1, account.getOut_frequency());
            ps.setInt(2, user.getId());
            //执行更新操作
            ps.executeUpdate();
            // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库连接
            ConnectSJK.closeConnection(conn);
        }
    }

    /**
     * 查询账户
     * @author David
     * @return 账户集合
     */
    public List<Account> checkaccount(){
        //定义集合保存查询到的账户信息
        List<Account> accountlist = new ArrayList<Account>();
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //查询账户列表
        String sql = "select * from car_account";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //循环判断结果集是否有效
            while(rs.next()){
                //实例化一个账户对象
                Account account = new Account();
                //对账户对象进行赋值
                account.setId(rs.getInt("id"));
                account.setUserid(rs.getInt("userid"));
                account.setMoney(rs.getDouble("money"));
                account.setLet_frequency(rs.getInt("let_frequency"));
                account.setOut_frequency(rs.getInt("out_frequency"));
                //将结果添加到集合中
                accountlist.add(account);
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库
            ConnectSJK.closeConnection(conn);
        }
        return accountlist;
    }

    /**
     * 根据用户id查账户信息
     */
    public Account useridaccount(Integer userid){
        //实例化一个账户对象
        Account account = new Account();
        //获取数据库连接Connection对象
        Connection conn = ConnectSJK.getConnection();
        //根据用户id查询账户
        String sql = "select * from car_account where userid=?";
        try {
            //获取preparedstatement对象
            PreparedStatement ps = conn.prepareStatement(sql);
            //对slq语句占位符参数进行动态赋值
            ps.setInt(1, userid);
            //执行查询获取结果集
            ResultSet rs = ps.executeQuery();
            //判断结果集是否有效
            if(rs.next()){
                //对账户对象进行赋值
                account.setId(rs.getInt("id"));
                account.setUserid(rs.getInt("userid"));
                account.setMoney(rs.getDouble("money"));
                account.setLet_frequency(rs.getInt("let_frequency"));
                account.setOut_frequency(rs.getInt("out_frequency"));
            }
            //释放此ResultSet对象的数据库和JDBC资源
            rs.close();
            //释放此preparedStatement对象的数据库和JDBC资源
            ps.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally{
            //关闭数据库
            ConnectSJK.closeConnection(conn);
        }
        return account;
    }
}

这是字符编码过滤器

package com.david.code;

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;

/**
 * 字符编码过滤器CharacterEncodingFilter 
 * @author
 */
public class CharacterEncodingFilter implements Filter{
    protected String encoding = null;
    protected FilterConfig filterConfig = null;

    public void init(FilterConfig filterConfig) throws ServletException{
        this.filterConfig = filterConfig;
        this.encoding = filterConfig.getInitParameter("encoding");
    }

    public void destroy(){
        this.encoding = null;
        this.filterConfig = null;
    }

    public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException{
        if(encoding != null){
            request.setCharacterEncoding(encoding);
            response.setContentType("text/html;charset="+encoding);
        }
        chain.doFilter(request, response);
    }
}

这是数据库连接ConnectSJK

package com.david.dao;

import java.sql.Connection;
import java.sql.DriverManager;
/**
 * 连接数据库
 */
public class ConnectSJK {
    public static Connection getConnection(){
        Connection conn = null;
        try {
            //加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //数据库连接URL
            String url = "jdbc:mysql://localhost:3306/test?user=root&password=123456&useUnicode=true&characterEncoding=UTF8";
            //获取数据库连接
            conn = DriverManager.getConnection(url);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        return conn;
    }

    //关闭数据库连接
    public static void closeConnection(Connection conn){
        //判断conn是否为空 
        if(conn != null){
            try {
                conn.close();           //关闭数据库连接
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }

    }
}

点击查看更多内容