精华内容
下载资源
问答
  • 使用的c3p0和DButils操作mysql数据库数据库文件已导入
  • JavaWeb——JDBC 操作数据库 五、删除数据 在前面几篇博客中,已经实现在 JSP 页面查询、修改和增加数据,现在实现从 JSP 页面删除数据。 上一篇

    JavaWeb——JDBC 操作数据库

    五、删除数据

    • 在前面几篇博客中,已经实现在 JSP 页面查询、修改和增加数据,现在实现从 JSP 页面删除数据。
    • 首先新建一个 Servlet 用于删除数据库的操作,代码如下:
      //@Date:2019/12/3
      // Author:御承扬
      //E-mail:2923616405@qq.com
      package com.lyq.ServletSet;
      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;
      import java.sql.Connection;
      import java.sql.DriverManager;
      import java.sql.PreparedStatement;
      import java.sql.SQLException;
      
      
      @WebServlet(name = "DeleteServlet", urlPatterns = "/DeleteServlet")
      public class DeleteServlet extends HttpServlet {
          protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      
          }
      
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              int id = Integer.parseInt(request.getParameter("id"));
              try {
                  Class.forName("com.mysql.jdbc.Driver");
                  String url = "jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8";
                  String username = "root";
                  String password = "*********";
                  Connection conn = null;
                  try {
                      conn = DriverManager.getConnection(url, username, password);
                      if(conn != null){
                          String sql = "delete from tb_books where id=?";
                          PreparedStatement ps = conn.prepareStatement(sql);
                          ps.setInt(1,id);
                          ps.executeUpdate();
                          ps.close();
                          conn.close();
                      }
                  } catch (SQLException e) {
                      e.printStackTrace();
                  }
              } catch (ClassNotFoundException e) {
                  e.printStackTrace();
              }
              response.sendRedirect("FindServlet");
          }
      }
      
    • 接着建立可视化的 JSP 页面,代码如下:
      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      <%@ page import="com.lyq.bean.Book"%>
      <%@ page import="java.util.List" %>
      <html>
      <head>
          <title>修改图书信息</title>
          <style type="text/css">
              body {
                  background: #d7c7e9;
                  align-items: center;
                  text-align: center;
              }
          </style>
          <script type="text/javascript">
              function check(form) {
                  with (form) {
                      if (bookCount.value === "") {
                          alert("图书数量不能为空");
                          return false;
                      }
                      return true;
                  }
              }
          </script>
      </head>
      <body>
      <table align="center" width="700" border="1" height="180" bordercolor="white" cellpadding="1"
             cellspacing="1">
          <tr bgcolor="white">
              <td align="center" colspan="7">
                  <h2>所有图书信息</h2>
              </td>
          </tr>
          <tr align="center" bgcolor="#e1ffc1">
              <td><b>ID</b></td>
              <td><b>图书名称</b></td>
              <td><b>价格</b></td>
              <td><b>数量</b></td>
              <td><b>作者</b></td>
              <td><b>修改数量</b></td>
              <td><b>删 除</b></td>
          </tr>
          <%
              List<Book> list = (List<Book>) request.getAttribute("list");
              if(list == null ||list.size() < 1){
                  out.print("没有数据");
              }else{
                  for(Book book:list){
      
      
          %>
              <tr align="center">
                  <td><%=book.getId()%>
                  </td>
                  <td><%=book.getName()%>
                  </td>
                  <td><%=book.getPrice()%>
                  </td>
                  <td><%=book.getBookCount()%>
                  </td>
                  <td><%=book.getAuthor()%>
                  </td>
                  <td>
                      <form action="${pageContext.request.contextPath}/UpdateServlet" method="post" onsubmit="return check(this)">
                          <input type="hidden" name="id" value="<%=book.getId()%>">
                          <label>
                              <input type="text" name="bookCount" size="3">
                          </label>
                          <input type="submit" value="修改">
                      </form>
                  </td>
                  <td>
                      <a href="${pageContext.request.contextPath}/DeleteServlet?id=<%=book.getId()%>">删除</a>
                  </td>
              </tr>
          <%
                  }
              }
          %>
          <tr bgcolor="white">
              <td align="center" colspan="3">
                  <input type="button" value="添加图书信息" onclick="window.location.href='http://localhost:8080/JavaWebProject1_war_exploded/JDBCOption/book.jsp'">
              </td>
              <td align="center" colspan="3">
                  <input type="button" value="图书信息查询" onclick="window.location.href='http://localhost:8080/JavaWebProject1_war_exploded/JDBCOption/book_list.jsp'">
              </td>
          </tr>
      </table>
      </body>
      </html>
      
    • 渲染效果如下:
      在这里插入图片描述
    • 在第五行点击删除,刷新页面后如下:
      在这里插入图片描述

    上一篇

    下一篇

    展开全文
  • 数据库javaweb的增删改查对数据库操作,会生成很多操作记录。
  • for (Student student : list) { %> ID 名字 年龄 性别 删除 在这里面可以写java代码 //request :内置对象 ArrayList ()%> ()%> ()%> ()%> /student?method=deleteById&id=()%>">删除 <% } %> student_insert.jsp /...

     

     private Integer id;
        private String name;
        private Integer age;
        private String gender;
    
        public Student() {
            // this(1, "zhangsan", 3, "男");
            // new Student(1, "zhangsan", 3, "男");
        }
    
        public Student(Integer id, String name, Integer age, String gender) {
            this.id = id;
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public String getGender() {
            return gender;
        }
    
        public void setGender(String gender) {
            this.gender = gender;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", gender='" + gender + '\'' +
                    '}';
        }

     

    @WebServlet("/student")
    public class StudentServlet extends HttpServlet {
    
    
        @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //解决post请求乱码问题
            req.setCharacterEncoding("UTF-8");
            System.out.println("HelloServlet.service");
    
            String method = req.getParameter("method");
            if(method == null || method.equals("")){
                method = "selectAll";
            }
            switch (method){
                case "selectAll":
                    selectAll(req,resp);
                    break;
                case "deleteById":
                    deleteById(req,resp);
                    break;
                case "insert":
                    insert(req,resp);
                    break;
            }
    
    
    
    
    
        }
    
        private void insert(HttpServletRequest req, HttpServletResponse resp) throws IOException {
            String name = req.getParameter("name");
            String age = req.getParameter("age");
            String gender = req.getParameter("gender");
            Connection connection = null;
            PreparedStatement statement = null;
            try {
                connection = JDBCUtil.getConnection();
                String  sql= "insert into student(name,age,gender) values(?,?,?)";
                statement = connection.prepareStatement(sql);
                statement.setString(1,name);
                statement.setInt(2,Integer.parseInt(age));
                statement.setString(3,gender);
                System.out.println(statement);
                int count = statement.executeUpdate();
                System.out.println("count:" + count);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            } finally {
                JDBCUtil.close(connection,statement,null);
            }
    
            resp.sendRedirect(req.getContextPath() + "/student?method=selectAll");
        }
    
        private void deleteById(HttpServletRequest req, HttpServletResponse resp) throws IOException {
            String id = req.getParameter("id");
            Connection connection = null;
            PreparedStatement statement = null;
            try {
                connection = JDBCUtil.getConnection();
                String  sql= "delete from student where id = ?";
                statement = connection.prepareStatement(sql);
                statement.setInt(1,Integer.parseInt(id));
                System.out.println(statement);
                int count = statement.executeUpdate();
                System.out.println("count:" + count);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            } finally {
                JDBCUtil.close(connection,statement,null);
            }
    
            resp.sendRedirect(req.getContextPath() + "/student?method=selectAll");
    
        }
    
        private void selectAll(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet resultSet = null;
            ArrayList<Student> list = null;
            try {
                connection = JDBCUtil.getConnection();
                String sql = "select id,name,age,gender from student";
                statement = connection.prepareStatement(sql);
                resultSet = statement.executeQuery();
                list = new ArrayList<>();
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");
                    int age = resultSet.getInt("age");
                    String gender = resultSet.getString("gender");
                    Student student = new Student(id, name, age, gender);
                    list.add(student);
                }
                for (Student student : list) {
                    System.out.println(student);
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            } finally {
                JDBCUtil.close(connection, statement, resultSet);
            }
            req.setAttribute("list", list);
    
            req.getRequestDispatcher("/student_list.jsp").forward(req, resp);
        }
    }

     student-list.jsp

    <body>
    <%--    ${list}--%>
    <a href="<%=request.getContextPath()%>/student_insert.jsp">添加</a>
        <table border="1" cellpadding="0">
            <tr>
                <td>ID</td>
                <td>名字</td>
                <td>年龄</td>
                <td>性别</td>
                <td>删除</td>
            </tr>
            <%
                // 在这里面可以写java代码
                //request :内置对象
                ArrayList<Student> list = (ArrayList<Student>) request.getAttribute("list");
                for (Student student : list) {
            %>
            <tr>
                <td><%=student.getId()%></td>
                <td><%=student.getName()%></td>
                <td><%=student.getAge()%></td>
                <td><%=student.getGender()%></td>
                <td><a href="<%=request.getContextPath()%>/student?method=deleteById&id=<%=student.getId()%>">删除</a> </td>
            </tr>
            <%
                }
            %>
    
        </table>
    </body>

     student_insert.jsp

    <body>
        <form action="<%=request.getContextPath()%>/student?method=insert" method="post">
            名字:<input type="text" name="name"/><br/>
            年龄:<input type="text" name="age"/><br/>
            性别:<input type="text" name="gender"/><br/>
            <input type="submit" value="添加"/>
        </form>
    </body>

    展开全文
  • JavaWeb——数据库(Mysql)

    千次阅读 2018-03-29 21:13:58
    数据库就是存储数据的仓库,其本质是一个文件系统,数据按照特定的格式将数据存储起来,用户可以对数据库中的数据进行增加,修改,删除及查询操作。 2、什么是数据库管理系统 数据库管理系统(DataBase ...

    1、什么是数据库
    数据库就是存储数据的仓库,其本质是一个文件系统,数据按照特定的格式将数据存储起来,用户可以对数据库中的数据进行增加,修改,删除及查询操作。
    2、什么是数据库管理系统
    数据库管理系统(DataBase Management System,DBMS):指一种操作和管理数据库的大型软件,用于建立、使用和维护数据库,对数据库进行统一管理和控制,以保证数据库的安全性和完整性。用户通过数据库管理系统访问数据库中表内的数据。
    3、数据库表
    数据库中以表为组织单位存储数据。
    表类似我们的Java类,每个字段都有对应的数据类型。
    那么用我们熟悉的java程序来与关系型数据对比,就会发现以下对应关系。
    类—–对应—–表
    类中属性—–对应—–表中字段
    一个对象—-对应——一条记录
    这里写图片描述
    4、SQL语法
    SQL语句可以单行或多行书写,以分号结尾
    MySQL数据库的SQL语句不区分大小写,建议使用大写,例如:SELECT * FROM user。
    这里写图片描述
    4.1 创建表

    -- 创建表结构
    CREATE TABLE users(
        uid INT PRIMARY KEY AUTO_INCREMENT,
        uname VARCHAR(20),
        uaddress VARCHAR(200)
    );
    -- 查看数据库
    SHOW DATABASES;
    -- 删除表
    DROP TABLE users;
    -- 查看数据库中的表
    SHOW TABLES;
    -- 查看表结构
    DESC users;
    
    /*
    添加列,添加字段
    ALTER TABLE users ADD tel INT;
    */
    
    DESC users;
    
    /*
    修改列,在原有的列上修改
    修改列名,数据类型约束
    ALTER TABLE users MODIFY tel VARCHAR(50)
    */
    /*
    修改列名
    ALTER TABLE users CHANGE tel newtel DOUBLE;
    */
    /*
    删除列
    ALTER TABLE users DROP newtel;
    */

    4.2 插入数据

    CREATE DATABASE mybase;
    SHOW DATABASES;
    CREATE TABLE product(
        -- 主键列,自动增长
        id INT PRIMARY KEY AUTO_INCREMENT,
        -- 商品名字,可变字符,非空
        pname VARCHAR(100) NOT NULL,
        -- 商品的价格,double
        price DOUBLE
    );
    INSERT INTO product (id,sname) VALUES (1,'记事本')
    /*
    添加数据格式,不考虑主键
    格式:
    insert into 表名 (列名) values (值)
    */
    INSERT INTO product (pname,price) VALUES ('洗衣机',12.01);
    /*
    添加数据格式,所有值全给出
    格式:
    insert into 表名 values (全列值)
    */
    INSERT INTO product VALUES (2,'微波炉',300.25);
    /*
    添加数据格式,批量写入
    格式:
    insert into 表名 (列名1,列名2,列名3) values 
    (值1,值2,值3),(值1,值2,值3),(值1,值2,值3)
    */
    INSERT INTO product(pname,price) VALUES('智能机器人',2599.98),
    ('沙发',599.98);

    4.3 修改表中的数据

    /*
    对数据进行更新操作
    数据在原有的基础上修改
    格式:
    update 表名 set1=值1,列2=值2 where 条件
    where 条件:数据中的唯一性
    */
    -- 修改智能机器人,价格上调到69999
    UPDATE product SET price=69999 WHERE id=3
    
    -- 修改沙发,名字改为冰箱,价格改为3222
    UPDATE product SET pname='冰箱',price=3222 WHERE id=4 
    /*
    修改条件的写法:
    id=6
    id<>6  id不等于6
    id<=6
    &&--->and
    ||--->or
    !---> not
    id in (1,2,3,4,5)
    id not in (1,2,3,4)
    */
    -- 将洗衣机和微波炉的价格都改为666
    UPDATE product SET price=666.33 WHERE id=1 OR id=2

    4.4 对表中的数据查询

    /*
    查询指定列数据
    格式:
        select 列名1,列名2 from 表名
    */
    SELECT zname,zmoney FROM zhangwu;
    /*
    查询所有列的数据
    格式:
        select * from 表名
    */
    SELECT * FROM zhangwu;
    /*
    查询去掉重复记录
    distinct 关键字 跟随列名
    */
    SELECT DISTINCT zname FROM zhangwu; 
    /*
    查询重新命名列
    as 关键字
    */
    SELECT zname AS '名称' FROM zhangwu;
    /*
    查询数据中,直接进行数学运算
    格式:
        列对数字进行计算
    */
    SELECT zname,zmoney+50 AS 'sum' FROM zhangwu;
    
    -- 查询所有的吃饭支出
    SELECT * FROM zhangwu WHERE zname='吃饭支出';
    -- 查询金额大于240
    SELECT * FROM zhangwu WHERE zmoney>200;
    -- 查询金额在2000到5000之间
    SELECT * FROM zhangwu WHERE zmoney>=200 AND zmoney<=500;
    -- 查询金额在2000到5000之间
    SELECT * FROM zhangwu WHERE zmoney BETWEEN 200 AND 500;
    -- 查询金额是100,200,500其中一个
    SELECT * FROM zhangwu WHERE zmoney=100 OR zmoney=200 OR zmoney=500
    SELECT * FROM zhangwu WHERE zmoney IN (100,247,500)
    
    -- like模糊查询必须配合通配符%(可以表示多个字符,_表示一个字符)
    -- 查询所有的支出
    SELECT * FROM zhangwu WHERE zname LIKE '%支出'
    -- 查询账务名字,五个字符的
    SELECT * FROM zhangwu WHERE zname LIKE '_____'
    -- 查询账务名不为空的
    SELECT * FROM zhangwu WHERE NOT (zname IS NULL);
    SELECT * FROM zhangwu WHERE zname IS NOT NULL;

    4.4.1 查询排序

    /*
    查询,对结果集进行排序
    升序,降序,对指定列排序
     order by 列名 [desc][asc]
     desc 降序
     asc  升序排列,可以不写
    */
    -- 查询账务表,价格进行升序
    SELECT * FROM zhangwu ORDER BY zmoney ASC;
    -- 查询账务表,价格进行降序
    SELECT * FROM zhangwu ORDER BY zmoney DESC;
    
    -- 查询账务表,查询所有的支出,对金额降序排序
    -- 先过滤条件 where 查询的结果再排序
    SELECT * FROM zhangwu WHERE zname LIKE '%支出%' ORDER BY zmoney DESC;

    4.4.2 聚合查询

    /*
    使用聚合函数查询计算,它是对一列数据进行计算
    
    */
    -- count 求和,对表中的数据的个数求和 count(列名)
    -- 查询统计账务表中,一共有多少条数据
    SELECT COUNT(*) AS 'count' FROM zhangwu
    -- sum求和,对一列中数据进行求和计算 sum(列名)
    -- 对账务表查询,多所有的金额求和计算
    SELECT SUM(zmoney) AS 'sum' FROM zhangwu
    -- 求和,统计所有支出的总金额,当其中一个为空的话则记为0
    SELECT SUM(zmoney) FROM zhangwu WHERE zname LIKE '%收入'
    -- max函数,对某列数据获取最大值
    SELECT MAX(zmoney) FROM zhangwu

    4.4.3 分组查询

    /*
    
    
    吃饭支出    共计多少
    工资收入    共计多少
    服装支出    共计多少
    股票收入    共计多少
    打麻将支出   共计多少
    
    分组查询:group by 分组的列名
    必须跟随聚合函数
    select 查询的时候,被分组的列,要出现在select选择列的后面
    */
    SELECT SUM(zmoney),zname FROM zhangwu GROUP BY zname
    -- 对zname内容进行分组查询,但是只要支出并排序
    SELECT SUM(zmoney) AS 'getsum',zname FROM zhangwu WHERE zname LIKE '%支出'
    GROUP BY zname ORDER BY getsum DESC;
    -- 对zname内容进行分组查询求和,但是只要支出,显示金额大于100
    -- 结果集分组查询后,再次进行筛选,不能使用where,分组后再次过滤使用关键字having
    SELECT SUM(zmoney) AS 'getsum',zname FROM zhangwu WHERE zname LIKE '%支出'
    GROUP BY zname HAVING getsum>100
    /*
    havingwhere的区别:
        having是在分组后对数据进行过滤
        where是在分组前对数据进行过滤
        having后面可以使用分组函数(统计函数也就是聚合函数)
        where后面不可以使用分组函数
    */

    4.4.4 分页查询

    -- 起始位置(要查询第几页-1)乘以第二个参数;第二个参数表示每页显示数目
    SELECT * FROM sort LIMIT 6,2;-- 要查询第四页,每页显示两条记录

    4.4.5 多表查询

    -- 订单表
    CREATE TABLE orders(
        oid VARCHAR(32)PRIMARY KEY,
        totalprice DOUBLE
    );
    -- 订单项表
    CREATE TABLE orderitem(
        oid VARCHAR(50),
        pid VARCHAR(50)
    );
    -- 添加约束,使得orderitem成为orders和orderitem之间的连接表
    ALTER TABLE orderitem ADD CONSTRAINT orderitem_fk FOREIGN KEY(oid)REFERENCES orders(oid);
    ALTER TABLE orderitem ADD CONSTRAINT orderitem1_fk FOREIGN KEY(pid)REFERENCES c_product(pid);
    
    SELECT * FROM category;
    SELECT * FROM c_product;
    
    -- 交叉连接,得到的是两个表的乘积
    SELECT * FROM category,c_product;
    -- 显示内连接(inner可以省略)
    SELECT * FROM category INNER JOIN c_product ON cid=category_id;
    -- 隐式内连接(内连接查询的是两个表的交集)
    SELECT * FROM category c,c_product p WHERE c.cid=p.category_id;
    -- 左外连接(查询的是左表的全部以及交集部分)
    SELECT * FROM category LEFT JOIN c_product ON cid=category_id;
    -- 右外连接(查询的是右表的全部以及交集部分)
    SELECT * FROM category RIGHT JOIN c_product ON cid=category_id;
    
    -- 子查询(一条select语句结果作为另一条select语法一部分,可以使查询条件、查询结果等)
    SELECT * FROM c_product WHERE category_id=(SELECT cid FROM category WHERE cname='化妆品');

    这里写图片描述
    4.4.6 主外键约束关系

    -- 分类表 主表
    CREATE TABLE category(
        cid VARCHAR(32) PRIMARY KEY,
        cname VARCHAR(100)
    );
    -- 商品表 从表
    CREATE TABLE c_product(
        pid VARCHAR(32) PRIMARY KEY,
        pname VARCHAR(40),
        price DOUBLE,
        category_id VARCHAR(32)
    );
    INSERT INTO category(cid,cname) VALUES('c001','家电');
    INSERT INTO category(cid,cname) VALUES('c002','服饰');
    INSERT INTO category(cid,cname) VALUES('c003','化妆品');
    
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p001','联想','5000','c001');
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p002','海尔','5000','c001');
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p003','雷神','5000','c001');
    
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p004','JACK JONES','800','c002');
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p005','真维斯','200','c002');
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p006','花花公子','440','c002');
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p007','劲霸','2000','c002');
    
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p008','香奈儿','800','c003');
    INSERT INTO c_product(pid,pname,price,category_id) VALUES('p009','相宜本草','200','c003');
    
    SELECT * FROM c_product;
    
    -- 声明外键约束
    ALTER TABLE c_product ADD FOREIGN KEY(category_id) REFERENCES category(cid); 
    
    -- 因为从表product有主表category的引用数据,所以在主表中是无法直接
    -- 删除与从表有关联的数据
    DELETE FROM category WHERE cid='c002';
    
    -- 要想删除,只有解除主从表的约束关系
    ALTER TABLE c_product DROP FOREIGN KEY category_id;
    -- 或者先删除从表中与主表有关系的数据,再删除主表中的数据

    4.4.7 删除数据

    /*
      删除表中的数据
      格式:
        delete from 表名 where 条件
    
        drop table 表名 删除整个数据表
    */
    -- 删除热水器
    DELETE FROM product WHERE id=8;

    5、JDBC
    JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。
    JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序。
    JDBC需要连接驱动,驱动是两个设备要进行通信,满足一定通信数据格式,数据格式由设备提供商规定,设备提供商为设备提供驱动软件,通过软件可以与该设备进行通信。
    这里写图片描述

    5.1.1 简单的JDBC操作数据库

    example 1 插入数据

    package cn.itcast.demo;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    import com.mysql.jdbc.Driver;
    
    /*
     * JDBC操作数据库的步骤:
     * 1、注册驱动
     *  告知JVM使用的是哪一个数据库的驱动
     * 2、获得连接
     *  使用JDBC中的类,完成对MySQL数据库的连接
     * 3、获得语句执行平台
     *  通过连接对象获取对SQL语句的执行者对象
     * 4、执行sql语句
     *  使用执行者对象,向数据库执行sql语句
     *  获取到数据库的执行后的结果
     * 5、处理结果
     * 6、释放资源(一堆close())
     * 
     * 
     * */
    public class JDBCDemo {
        public static void main(String[] args) throws ClassNotFoundException, SQLException {
            //1、注册驱动反射技术,将驱动类加入到内存
    
            //使用java.sql.DriverManager类静态方法registerDriver(Driver driver)
            //Driver是一个接口,参数传递,Mysql驱动程序中的实现类
            //使用DriverManager.registerDriver(new Driver)这种方式通过读源码发现注册2次驱动,所以不建议这种方式
        //  DriverManager.registerDriver(new Driver());
            Class.forName("com.mysql.jdbc.Driver");
            //2、获得数据库连接DriverManager类中静态方法
            //static Connection getConnection(String url,String user,String password)
            //返回值是Connection接口的实现类,在mysql驱动程序中
            //url:数据库地址   格式:jdbc:mysql://连接主机IP:端口号/数据库名字
            String url="jdbc:mysql://localhost:3306/mybase";
            String username="root";
            String password="123456";
            Connection con=DriverManager.getConnection(url, username, password);
    
            //3、获得语句执行平台,通过数据库连接对象,获取到sql语句的执行者对象
            //con对象调用方法 statement createStatement() 获取statement对象,将sql语句发送到数据库
            //返回值是statement接口的实现类对象,在mysql驱动程序中
            Statement stat=con.createStatement(); 
    
            //4、执行sql语句
            //通过执行者对象调用方法执行sql语句,获取结果
            //int executeUpdate(String sql)执行数据库中的sql语句,insert delete update
            //返回值int 操作成功数据表多少行
            int row=stat.executeUpdate
                    ("INSERT INTO sort(sname,sprice,sdesc) VALUES('汽车用品',50000,'疯狂涨价')");
            System.out.println(row);
            //6、释放资源  一堆close()
            stat.close();
            con.close();
        }
    }

    example2 查询数据

    package cn.itcast.demo;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    
    public class JDBCDemo1 {
    
        public static void main(String[] args)throws Exception {
            // TODO Auto-generated method stub
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、获取连接
            String url="jdbc:mysql://localhost:3306/mybase";
            String user="root";
            String password="123456";
            Connection con=DriverManager.getConnection(url, user, password);
            //3、获得数据库执行者对象
            Statement stat=con.createStatement();
            //4、执行sql语句获取结果集
            //ResultSet executeQuery(String sql)执行sql语句中的select查询
            //返回值ResultSet接口的实现类对象,实现类在mysql驱动中
            String sql="SELECT * FROM sort";
            ResultSet rs=stat.executeQuery(sql);
            //5、处理结果集,返回为真的时候说明有查询有结果,返回为假的时候则该查询没有结果,也就是不存在符合该查询的数据
            while(rs.next()) {
                //获取每列数据,使用的是ResultSet接口中的方法getXX方法参数,建议写String列名
                System.out.println(rs.getInt("sid")+"  "+rs.getString("sname")+
                        "   "+rs.getDouble("sprice")+"   "+rs.getString("sdesc"));
    
            }
            rs.close();
            stat.close();
    
        }
    
    }

    5.1.2 sql预编译存储式操作数据库(防注入攻击)

    容易注入攻击

    package cn.itcast.demo;
    //sql注入攻击用户登陆
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.util.Scanner;
    
    public class JDBCDemo3 {
    
        public static void main(String[] args) throws Exception {
            // TODO Auto-generated method stub
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、获取连接
            String url="jdbc:mysql://localhost:3306/mybase";
            String user="root";
            String password="123456";
            Connection con=DriverManager.getConnection(url, user, password);
            //3、获取sql的执行对象
            Statement stat=con.createStatement();
            //4、执行sql语句,获取结果集,查询
            Scanner sc=new Scanner(System.in);
            String us=sc.nextLine();
            String pass=sc.nextLine();
    
            String sql="SELECT * FROM users WHERE username='"+us+"' AND PASSWORD='"+pass+"'";
            ResultSet rs=stat.executeQuery(sql);
            while(rs.next()) {
                /*
                 * 当这么写的时候就注入攻击成功:
                 * adfafa
                 * dasfafdas 'or'1=1
                 * 
                 * */
                System.out.println(rs.getString("username")+"   "+rs.getString("password"));
            }
            rs.close();
            stat.close();
            con.close();
    
        }
    
    }

    防注入攻击

    package cn.itcast.demo;
    /*
     * java程序实现用户登陆,用户名和密码,数据库检查
     * 防止注入攻击
     * statement接口实现类,作用是执行sql语句,返回结果集
     * 有一个子接口PrepareStatement(sql预编译存储,多次高效的执行sql)
     * PrepareStatement的实现类也在驱动中,如何获取接口的实现类
     * 
     * 是Connection数据连接对象的方法
     * PrepareStatement prepareStatement(String sql)
     * 
     * */
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.util.Scanner;
    
    public class JDBCDemo2 {
    
        public static void main(String[] args) throws Exception {
            // TODO Auto-generated method stub
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、获取连接
            String url="jdbc:mysql://localhost:3306/mybase";
            String user="root";
            String password="123456";
            Connection con=DriverManager.getConnection(url, user, password);
    
            //4、执行sql语句,获取结果集,查询
            Scanner sc=new Scanner(System.in);
            String us=sc.nextLine();
            String pass=sc.nextLine();
    
            String sql="SELECT * FROM users WHERE username=? AND PASSWORD=?";
    
            //获取sql的执行对象,调用Connection接口的方法PrepareStatement,获取prepareStatement接口的实现类
            //方法中参数,sql语句中的参数全部采用问号占位符
            PreparedStatement pst=con.prepareStatement(sql);
            //调用pst对象set方法,设置问号占位符上的参数
            pst.setObject(1, us);
            pst.setObject(2, pass);
    
            //调用方法,执行sql,获取结果集
            ResultSet rs=pst.executeQuery();//之所以这里面不用放sql语句是因为con.prepareStatement(sql)已经编译好了
            while(rs.next()) {
                System.out.println(rs.getString("username")+"   "+rs.getString("password"));
            }
            rs.close();
            pst.close();
            con.close();
    
        }
    
    }

    更新数据操作

    package cn.itcast.demo;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    
    public class JDBCDemo4 {
    
        public static void main(String[] args) throws Exception{
            // TODO Auto-generated method stub
            /*
             * 使用PrepareStatement接口,实现数据表的更新操作
             * 
             * */
            Class.forName("com.mysql.jdbc.Driver");
            String url="jdbc:mysql://localhost:3306/mybase";
            String user="root";
            String password="123456";
            Connection con=DriverManager.getConnection(url, user, password);
            //拼写修改的sql语句,采用?占位
            String sql="UPDATE sort SET sname=?,sprice=? WHERE sid=?";
            //调用数据库连接对象con的方法prepareStatement获取sql语句的编译对象
            PreparedStatement pst=con.prepareStatement(sql);
            //调用pst的方法setXXX设置?占位
            pst.setObject(1, "汽车美容");
            pst.setObject(2, 4999988);
            pst.setObject(3, 7);
            //调用pst方法执行sql语句
            pst.executeUpdate();
    
            pst.close();
            con.close();
        }
    
    }

    数据查询

    package cn.itcast.demo;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    public class JDBCDemo5 {
    
        public static void main(String[] args) throws Exception{
            // TODO Auto-generated method stub
            /*
             * 使用PrepareStatement接口,实现数据表的查询操作
             * 
             * */
            Class.forName("com.mysql.jdbc.Driver");
            String url="jdbc:mysql://localhost:3306/mybase";
            String user="root";
            String password="123456";
            Connection con=DriverManager.getConnection(url, user, password);
            //拼写修改的sql语句,采用?占位
            String sql="SELECT * FROM sort";
            //调用数据库连接对象con的方法prepareStatement获取sql语句的编译对象
            PreparedStatement pst=con.prepareStatement(sql);
            //调用pst方法执行sql语句
            ResultSet rs=pst.executeQuery();
            while(rs.next()) {
                System.out.println(rs.getString("sid")+"   "+rs.getString("sname")+
                        "   "+rs.getString("sprice")+"   "+rs.getString("sdesc"));
            }
            rs.close();
            pst.close();
            con.close();
        }
    
    }

    封装查询到的数据
    Sort.java

    package cn.itcast.domain;
    
    public class Sort {
        private int sid;
        private String sname;
        private double sprice;
        private String sdesc;
    
    
        public Sort(int sid, String sname, double sprice, String sdesc) {
            this.sid = sid;
            this.sname = sname;
            this.sprice = sprice;
            this.sdesc = sdesc;
        }
    
        public Sort() {
            super();
            // TODO Auto-generated constructor stub
        }
    
        public int getSid() {
            return sid;
        }
        public void setSid(int sid) {
            this.sid = sid;
        }
        public String getSname() {
            return sname;
        }
        public void setSname(String sname) {
            this.sname = sname;
        }
        public double getSprice() {
            return sprice;
        }
        public void setSprice(double sprice) {
            this.sprice = sprice;
        }
        public String getSdesc() {
            return sdesc;
        }
        public void setSdesc(String sdesc) {
            this.sdesc = sdesc;
        }
    
        @Override
        public String toString() {
            return "Sort [sid=" + sid + ", sname=" + sname + ", sprice=" + sprice + ", sdesc=" + sdesc + "]";
        }
    
    }
    package cn.itcast.demo2;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import cn.itcast.domain.Sort;
    import cn.itcast.jdbcutil.JDBCUtils;
    
    /*
     * JDBC读取数据表sort,每行数据封装到sort类的对象中
     * 很多个Sort类对象,存储到List集合中
     * 
     * */
    
    public class JDBCDemo1 {
        public static void main(String[] args) throws Exception {
            //使用JDBC工具类,直接获取数据库连接对象
            Connection con=JDBCUtils.getConnection();
            //连接获取数据库sql语句执行者对象
            PreparedStatement pst=con.prepareStatement("SELECT * FROM sort");
            //调用查询方法,获取结果集
            ResultSet rs=pst.executeQuery();
            //创建集合对象
            List<Sort>list=new ArrayList<Sort>();
            while(rs.next()) {
                //获取到每个列数据,封装到Sort对象中
                Sort s=new Sort(rs.getInt("sid"),rs.getString("sname"),rs.getDouble("sprice"),rs.getString("sdesc"));
                //封装的sort对象,存储到集合中
                list.add(s);
            }
            JDBCUtils.close(con, rs, pst);
            //遍历List集合
            for(Sort s:list) {
                System.out.println(s);
            }
        }
    
    
    }

    加载配置文件的方式连接数据库

    database.properties

    driverClass=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/mybase
    username=root
    password=123456
    package cn.itcast.demo2;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.Properties;
    /*
     * 加载properties配置文件
     * IO读取文件,键值对存储到集合
     * 从集合中以键值对方式获取数据库的连接信息,完成数据库的连接
     * 
     * */
    public class PropertiesDemo {
    
        public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
            // TODO Auto-generated method stub
            //使用类的加载器
            InputStream in=PropertiesDemo.class.getClassLoader().getResourceAsStream("database.properties");
            System.out.println(in);
            Properties pro=new Properties();
            pro.load(in);
            //获取集合中的键值对
            String driverClass=pro.getProperty("driverClass");
            String url=pro.getProperty("url");
            String username=pro.getProperty("username");
            String password=pro.getProperty("password");
            Class.forName(driverClass);
            Connection con=DriverManager.getConnection(url, username, password);
            System.out.println(con);
        }
    
    }

    5.2 使用DBUtils工具操作数据库
    这里写图片描述

    自定义数据库连接类JDBCUtils.java

    package cn.itcast.jdbcutil;
    
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.util.Properties;
    
    /*
     * 编写JDBC的工具类,获取数据库的连接对象采用
     * 采用读取配置文件的方式
     * 读取文件获取连接,执行一次,采用static代码块,
     * 
     * */
    public class JDBCUtilsConfig {
        private static Connection con;
        private static String driverClass;
        private static String url;
        private static String username;
        private static String password;
        static {
            try {
            readConfig();
            Class.forName(driverClass);
            con=DriverManager.getConnection(url, username, password);
            }catch(Exception e) {
                throw new RuntimeException("数据库连接失败");
            }
        }
        private static void readConfig() throws Exception{
            InputStream in=JDBCUtilsConfig.class.getClassLoader().getResourceAsStream("database.properties");
            Properties pro=new Properties();
            pro.load(in);
            driverClass=pro.getProperty("driverClass");
            url=pro.getProperty("url");
            username=pro.getProperty("username");
            password=pro.getProperty("password");
        }
        public static Connection getConnection() {
            return con;
        }
    }

    DBUtils增删改数据库

    package cn.itcast.demo2;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    
    import cn.itcast.jdbcutil.JDBCUtils;
    import cn.itcast.jdbcutil.JDBCUtilsConfig;
    
    /*
     * 使用QueryRunner类实现对数据表的insert delete update
     * 调用QueryRunner类的方法 update(Connection con,String sql,Object...param)
     * Object...param是可变参数,Object类型,sql语句会出现?占位符
     * 
     * */
    
    public class QueryRunnerDemo {
    
        private static Connection con=JDBCUtilsConfig.getConnection();
        public static void main(String[] agrs) throws SQLException {
            //insert();
    //      update();
            delete();
        }
        /*
         * 定义方法,使用QueryRunner类的方法update向数据表中添加数据
         * */
        public static void insert() throws SQLException {
            //创建QueryRunner类对象
            QueryRunner qr=new QueryRunner();
            String sql="INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
            //将三个?占位符的实际参数,写在数组中
            Object[] params= {"体育用品",275.32,"购买体育用品"};
            //调用QueryRunner类的方法update执行sql语句
            int row=qr.update(con,sql,params);
            System.out.println(row);
            DbUtils.closeQuietly(con);
        }
        /*
         * 定义方法,使用QueryRunner类的方法update将数据表的数据修改
         * */
        public static void update() throws SQLException {
            //创建QuerRunner类对象
            QueryRunner qr=new QueryRunner();
            //写修改数据的sql语句
            String sql="UPDATE sort SET sname=?,sprice=?,sdesc=? WHERE sid=?";
            //定义Object数组,存储?中的参数
            Object[] params= {"花卉",100.88,"情人节玫瑰花",4};
            //调用QueryRunner方法update
            int row=qr.update(con,sql,params);
            System.out.println(row);
        }
        /*
         * 定义方法,使用QueryRunner类的方法delete将数据表的数据删除
         * 
         * */
        public static void delete() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="DELETE FROM sort WHERE sid=?";
            int row=qr.update(con, sql,7);
            System.out.println(row);
            DbUtils.closeQuietly(con);
        }
    }

    DBUtils进行数据库的数据查询
    这里写图片描述

    package cn.itcast.demo2;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.ArrayHandler;
    import org.apache.commons.dbutils.handlers.ArrayListHandler;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    import org.apache.commons.dbutils.handlers.ColumnListHandler;
    import org.apache.commons.dbutils.handlers.MapHandler;
    import org.apache.commons.dbutils.handlers.MapListHandler;
    import org.apache.commons.dbutils.handlers.ScalarHandler;
    
    import cn.itcast.domain.Sort;
    import cn.itcast.jdbcutil.JDBCUtilsConfig;
    
    /*
     * QueryRunner数据查询操作:
     * 调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r,Object...params)
     * ResultSetHandler r结果集的处理方式,传递ResultSetHandler接口实现类
     * Object..params SQL语句中的?占位符
     * 
     * 注意:query方法返回值,返回的是T 泛型,具体返回值类型,跟随结果集处理方式变化
     * 
     * 
     * */
    public class QueryRunnerDemo1 {
    
        private static Connection con=JDBCUtilsConfig.getConnection();
        public static void main(String[] args) throws SQLException {
            // TODO Auto-generated method stub
    //      arrayHandler();
    //      arrayListHandler();
    //      beanHandler();
    //      beanListHandler();
    //      columnListHandler();
    //      scalarHandler();
    //      mapHandler();
            mapListHandler();
        }
        /*
         * 结果集第一种处理方式:ArrayHandler
         * 将结果集的第一行存储到对象数组中 Object[]
         * 注意:被封装成数据到JavaBean对象,Sort类必须有空参构造函数,因为query是调用空参构造函数进行初始化的
         * */
        public static void arrayHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用方法query执行查询,传递连接对象,sql语句,结果集处理方式的实现类
            //返回对象数组
            Object[] result=qr.query(con,sql,new ArrayHandler());
            for(Object obj:result) {
                System.out.print(obj);
            }
        }
        /*
         * 结果集第二种处理方法:ArrayListHandler
         * 将结果集的每一行封装到对象数组中,出现很多对象数组,对象数组存储到List集合
         * 
         * */
        public static void arrayListHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用query方法,结果集处理的参数上,传递实现ArrayListHandler()
            List<Object[]>result=qr.query(con, sql, new ArrayListHandler());
            for(Object[] objs:result) {
                //遍历对象数组
                for(Object obj:objs) {
                    System.out.print(obj+"   ");
                }
                System.out.println();
            }
        }
        /*
         * 结果集第三种处理方法:BeanHandler
         * 将结果的第一行数据,封装成JavaBean对象
         * 
         * */
        public static void beanHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用方法传递结果集实现类BeanHandler
            Sort s=qr.query(con, sql, new BeanHandler<Sort>(Sort.class));
            System.out.println(s);
        }
        /*
         * 结果集第四种处理方式,BeanListHandler
         * 将数据结果集的每一行数据封装成JavaBean对象
         * 多个JavaBean对象封装到List集合中
         * 
         * */
        public static void beanListHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用方法传递结果集的实现类BeanListHandler
            List<Sort>list=qr.query(con,sql,new BeanListHandler<Sort>(Sort.class));
            for(Sort s: list) {
                System.out.println(s);
            }
    
        }
        /*
         * 结果处理第五种方法,ColumnListHandler
         * 结果集,指定列的数据,存储到List集合
         * List<Object>每个列数据类型不同
         * 
         * */
        public static void columnListHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用方法query,传递结果集实现类ColumnListHandler
            //实现类构造方法中,使用字符串的列名
            List<Object>list=qr.query(con, sql,new ColumnListHandler<Object>("sname"));
            for(Object obj:list) {
                System.out.println(obj);
            }
        }
        /*
         * 结果集第六种方法,ScalarHandler
         * 对于查询后只有一个结果
         * 
         * */
        public static void scalarHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用query,传递结果集处理实现类ScalarHandler
            Long count=qr.query(con,sql,new ScalarHandler<Long>());
            System.out.println(count);
        }
        /*
         * 结果集第七种处理方法,MapHandler
         * 将结果集的第一行数据封装到Map集合中
         * Map<键,值>  键:列名   值:这列的数据
         * 
         * */
        public static void mapHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用方法query传递结果集实现类MapHandler
            //返回值:Map集合,Map接口实现类,泛型
            Map<String,Object>map=qr.query(con, sql, new MapHandler());
            //遍历Map集合
            for(String key:map.keySet()) {
                System.out.println(key+".."+map.get(key));
            }
    
        }
        /*
         * 结果集的第八种处理方法,MapListHandler
         * 将结果集每一行存储到Map集合,键:列名,值:数据
         * Map集合过多,存储到List集合
         * */
        public static void mapListHandler() throws SQLException {
            QueryRunner qr=new QueryRunner();
            String sql="SELECT * FROM sort";
            //调用方法query,传递结果集实现类MapListHandler
            //返回值List集合,存储的是Map集合
            List<Map<String,Object>>list=qr.query(con,sql,new MapListHandler());
            //遍历集合list
            for(Map<String,Object>map:list) {
                for(String key:map.keySet()) {
                    System.out.println(key+"..."+map.get(key));
                }
                System.out.println();
            }
        }
    }

    5.3 dbcp连接池实现数据库的连接

    这里写图片描述
    这里写图片描述

    package cn.itcast.demo3;
    
    import java.sql.Connection;
    
    import org.apache.commons.dbcp.BasicDataSource;
    
    public class DataSourceDemo {
        /*
         * 连接池jar包中定义好一个类BasicDataSource
         * 实现类数据源的规范接口javax.sql.DataSource
         * 
         * */
        public static void main(String args[]) {
            //创建DataSource接口的实现类对象
            //实现类
            BasicDataSource dataSource=new BasicDataSource();
            //连接数据库的4个最基本信息,通过对象方法setXXX设置进来
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/mybase");
            dataSource.setUsername("root");
            dataSource.setPassword("123456");
            try {
                //调用对象方法getConnection获取数据库的连接
                Connection con=dataSource.getConnection();
                System.out.println(con);
            }catch(Exception e) {
                throw new RuntimeException("数据库连接失败");
            }
        }
    }

    自定义dbcp连接池工具类
    JDBCUtils1.java

    package cn.itcast.demo3;
    
    import javax.sql.DataSource;
    
    import org.apache.commons.dbcp.BasicDataSource;
    
    /*
     * 自定义dbcp连接池的工具类
     * 
     * */
    public class JDBCUtils1 {
    
            //创建出BasicDataSource类对象
            private static BasicDataSource datasource=new BasicDataSource();
            //静态代码块,对象BasicDataSource对象中的配置,自定义
            static {
                datasource.setDriverClassName("com.mysql.jdbc.Driver");
                datasource.setUrl("jdbc:mysql://localhost:3306/mybase");
                datasource.setUsername("root");
                datasource.setPassword("123456");
                //对象连接池中的连接数量配置
                datasource.setInitialSize(10);//初始化的连接数
                datasource.setMaxActive(8);//最大连接数
                datasource.setMaxIdle(5);//最大空闲数
                datasource.setMinIdle(1);//最小空闲数
    
            }
            //定义静态方法,返回BasicDataSource类的对象
            public static DataSource getDataSource() {
                return datasource;
            }
    
        }
    

    DBUtils+dbcp连接池实现数据库的操作

    package cn.itcast.demo3;
    
    import java.util.List;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.ArrayListHandler;
    
    /*
     * 测试写好的工具类
     * 提供的是一个DataSource接口的数据源
     * QueryRunner类构造方法,接收DataSource接口的实现类
     * 后面调用方法updata,query,无需传递他们Connection连接对象
     * 
     * 
     * */
    public class QueryRunnerDemo {
        //定义2个方法,实现数据表的添加,数据表查询
            //QueryRunner类对象,写在类成员位置
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
    
    //      insert();
            select();
        }
        private static QueryRunner qr=new QueryRunner(JDBCUtils1.getDataSource());
        //数据表添加数据
        public static void insert() {
            String sql="INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
            Object[]params= {"水果",100.12,"刚刚上市的核桃"};
            try {
                int row=qr.update(sql, params);
                System.out.println(row);
    
            }catch(Exception e) {
                throw new RuntimeException("数据添加失败");
            }
        }
        //数据表的查询
        public static void select() {
            String sql="SELECT * FROM sort";
            try {
                List<Object[]>list=qr.query(sql,new ArrayListHandler());
                for(Object[] objs:list) {
                    for(Object obj:objs) {
                        System.out.println(obj+"\t");
                    }
                    System.out.println();
                }
            }catch(Exception e){
                throw new RuntimeException("查询失败");
            }
        }
    
    
    }

    自定义连接池

    package cn.itcast.demo4;
    
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.sql.SQLFeatureNotSupportedException;
    import java.util.LinkedList;
    import java.util.logging.Logger;
    
    import javax.sql.DataSource;
    
    import cn.itcast.jdbcutil.JDBCUtils;
    /*
     * 自定义连接池
     * 
     * */
    public class MyDataSource implements DataSource {
    
        //1、创建1个容器用于存储Connection对象
        private static LinkedList<Connection> pool=new LinkedList<Connection>();
        //2、创建5个连接放到容器中去
        static {
                for(int i=0;i<5;i++) {
                    Connection conn=JDBCUtils.getConnection();
                    pool.add(conn);
                }
            }
    
        @Override
        public Connection getConnection() throws SQLException {
            // TODO Auto-generated method stub
            Connection conn=null;
            //3、使用前先判断
            if(pool.size()==0) {
                //4、池子里面没有我们再创建一些
                for(int i=0;i<5;i++) {
                    conn=JDBCUtils.getConnection();
                    pool.add(conn);
                }
            }
            //5、从池子里面获取一个连接对象Connection
            conn=pool.remove(0);
            return conn;
        }
        /*
         * 归还连接对象到连接池中去
         * */
        public void backConnection(Connection conn) {
            pool.add(conn);
        }
    
    
        @Override
        public PrintWriter getLogWriter() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
        @Override
        public void setLogWriter(PrintWriter out) throws SQLException {
            // TODO Auto-generated method stub
    
        }
        @Override
        public void setLoginTimeout(int seconds) throws SQLException {
            // TODO Auto-generated method stub
    
        }
        @Override
        public int getLoginTimeout() throws SQLException {
            // TODO Auto-generated method stub
            return 0;
        }
        @Override
        public Logger getParentLogger() throws SQLFeatureNotSupportedException {
            // TODO Auto-generated method stub
            return null;
        }
        @Override
        public <T> T unwrap(Class<T> iface) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
        @Override
        public boolean isWrapperFor(Class<?> iface) throws SQLException {
            // TODO Auto-generated method stub
            return false;
        }
        @Override
        public Connection getConnection(String username, String password) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    }

    采用装饰器模式自定义连接池

    JDBCUtils.java

    package cn.itcast.jdbcutil;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    /*
     * 实现JDBC的工具类
     * 定义方法,直接返回数据库的连接对象
     * 
     * 定义方法,关闭对象
     * */
    public class JDBCUtils {
        private JDBCUtils() {}
        private static Connection con;
        static {
            try {
            Class.forName("com.mysql.jdbc.Driver");
            String url="jdbc:mysql://localhost:3306/mybase";
            String user="root";
            String password="123456";
            con=DriverManager.getConnection(url,user,password);
            }catch(Exception e) {
                throw new RuntimeException(e+"数据库连接失败");
            }
    
        }
        /*
         * 定义静态方法,返回数据库的连接对象
         * */
        public static Connection getConnection() {
            return con;
        }
        public static void close(Connection con,ResultSet rs,Statement stat) {
            if(rs!=null) {
                try {
                    rs.close();
                }catch(SQLException e) {}
            }
            if(stat!=null) {
                try {
                    stat.close();
                }catch(SQLException e) {}
            }
            if(con!=null) {
                try {
                    con.close();
                }catch(SQLException e) {}
            }
        }
    
        public static void close(Connection con,Statement stat) {
            if(stat!=null) {
                try {
                    stat.close();
                }catch(SQLException e) {}
            }
            if(con!=null) {
                try {
                    con.close();
                }catch(SQLException e) {}
            }
        }
    }

    MyConnection.java

    package cn.itcast.demo4;
    
    import java.sql.Array;
    import java.sql.Blob;
    import java.sql.CallableStatement;
    import java.sql.Clob;
    import java.sql.Connection;
    import java.sql.DatabaseMetaData;
    import java.sql.NClob;
    import java.sql.PreparedStatement;
    import java.sql.SQLClientInfoException;
    import java.sql.SQLException;
    import java.sql.SQLWarning;
    import java.sql.SQLXML;
    import java.sql.Savepoint;
    import java.sql.Statement;
    import java.sql.Struct;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Properties;
    import java.util.concurrent.Executor;
    /*
     * 装饰器模式
     * 
     * */
    //1、实现同一个接口Connection
    public class MyConnection implements Connection{
        //3、定义一个变量
        private Connection conn;
        private LinkedList<Connection>pool;
        //2、编写一个构造方法(参数使用了面向对象的多态性)
        public MyConnection(Connection conn,LinkedList<Connection>pool) {
            this.conn=conn;
            this.pool=pool;
        }
        //4、书写需要增强的方法
        @Override
        public void close() throws SQLException {
            // TODO Auto-generated method stub
            pool.add(conn);
        }
    
    
        @Override
        public <T> T unwrap(Class<T> iface) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public boolean isWrapperFor(Class<?> iface) throws SQLException {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public Statement createStatement() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public PreparedStatement prepareStatement(String sql) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public CallableStatement prepareCall(String sql) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public String nativeSQL(String sql) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void setAutoCommit(boolean autoCommit) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public boolean getAutoCommit() throws SQLException {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public void commit() throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void rollback() throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
    
    
        @Override
        public boolean isClosed() throws SQLException {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public DatabaseMetaData getMetaData() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void setReadOnly(boolean readOnly) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public boolean isReadOnly() throws SQLException {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public void setCatalog(String catalog) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public String getCatalog() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void setTransactionIsolation(int level) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public int getTransactionIsolation() throws SQLException {
            // TODO Auto-generated method stub
            return 0;
        }
    
        @Override
        public SQLWarning getWarnings() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void clearWarnings() throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
                throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public Map<String, Class<?>> getTypeMap() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void setHoldability(int holdability) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public int getHoldability() throws SQLException {
            // TODO Auto-generated method stub
            return 0;
        }
    
        @Override
        public Savepoint setSavepoint() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public Savepoint setSavepoint(String name) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void rollback(Savepoint savepoint) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void releaseSavepoint(Savepoint savepoint) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
                throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
                int resultSetHoldability) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
                int resultSetHoldability) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public Clob createClob() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public Blob createBlob() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public NClob createNClob() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public SQLXML createSQLXML() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public boolean isValid(int timeout) throws SQLException {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public void setClientInfo(String name, String value) throws SQLClientInfoException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void setClientInfo(Properties properties) throws SQLClientInfoException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public String getClientInfo(String name) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public Properties getClientInfo() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void setSchema(String schema) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public String getSchema() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public void abort(Executor executor) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public int getNetworkTimeout() throws SQLException {
            // TODO Auto-generated method stub
            return 0;
        }
    
    }

    定义连接池

    package cn.itcast.demo4;
    
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.sql.SQLFeatureNotSupportedException;
    import java.util.LinkedList;
    import java.util.logging.Logger;
    
    import javax.sql.DataSource;
    
    import cn.itcast.jdbcutil.JDBCUtils;
    /*
     * 自定义连接池
     * 
     * */
    public class MyDataSource1 implements DataSource {
    
        //1、创建1个容器用于存储Connection对象
        private static LinkedList<Connection> pool=new LinkedList<Connection>();
        //2、创建5个连接放到容器中去
        static {
                for(int i=0;i<5;i++) {
                    Connection conn=JDBCUtils.getConnection();
                    //放入池子中connection对象已经经过改造了
                    MyConnection myconn=new MyConnection(conn,pool);
                    pool.add(myconn);
                }
            }
    
        @Override
        public Connection getConnection() throws SQLException {
            // TODO Auto-generated method stub
            Connection conn=null;
            //3、使用前先判断
            if(pool.size()==0) {
                //4、池子里面没有我们再创建一些
                for(int i=0;i<5;i++) {
                    conn=JDBCUtils.getConnection();
                    //放入池子中connection对象已经经过改造了
                    MyConnection myconn=new MyConnection(conn,pool);
                    pool.add(myconn);
                }
            }
            //5、从池子里面获取一个连接对象Connection
            conn=pool.remove(0);
            return conn;
        }
        /*
         * 归还连接对象到连接池中去
         * */
        public void backConnection(Connection conn) {
             pool.add(conn);
        }
    
    
        @Override
        public PrintWriter getLogWriter() throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
        @Override
        public void setLogWriter(PrintWriter out) throws SQLException {
            // TODO Auto-generated method stub
    
        }
        @Override
        public void setLoginTimeout(int seconds) throws SQLException {
            // TODO Auto-generated method stub
    
        }
        @Override
        public int getLoginTimeout() throws SQLException {
            // TODO Auto-generated method stub
            return 0;
        }
        @Override
        public Logger getParentLogger() throws SQLFeatureNotSupportedException {
            // TODO Auto-generated method stub
            return null;
        }
        @Override
        public <T> T unwrap(Class<T> iface) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
        @Override
        public boolean isWrapperFor(Class<?> iface) throws SQLException {
            // TODO Auto-generated method stub
            return false;
        }
        @Override
        public Connection getConnection(String username, String password) throws SQLException {
            // TODO Auto-generated method stub
            return null;
        }
    }

    5.4 C3P0连接池(常用,因为它只要修改配置就可以轻松的更换数据库以及用户)

    c3p0-config.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <c3p0-config>
    
      <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///mybase</property>
        <property name="user">root</property>
        <property name="password">123456</property>
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">20</property>
      </default-config>
    
      <named-config name="ctgu"> 
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///mybase</property>
        <property name="user">root</property>
        <property name="password">123456</property>
      </named-config>
    
    
    </c3p0-config>
    package cn.itcast.C3P0;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    import javax.sql.DataSource;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    public class C3P0Utils {
        private static ComboPooledDataSource dataSource=new ComboPooledDataSource();//使用的默认配置
        //private static ComboPooledDataSource dataSource=new ComboPooledDataSource("ctgu");//使用的自定义配置
        public static DataSource getDataSource() {
            return dataSource;
        }
        public static Connection getConnection() {
            try {
                return dataSource.getConnection();
            }catch(SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }

    案例应用——管家婆记账软件
    这里写图片描述

    常用的项目分析逻辑
    这里写图片描述
    这里写图片描述
    view层作用: 视图层,即项目中的界面
    controller层作用: 控制层, 获取界面上的数据,为界面设置数据; 将要实现的功能交给业务层处理
    service层作用: 业务层, 功能的实现, 与controller控制层和数据访问层DAO交互, 将对数据库的操作交给DAO数据访问层来处理
    dao层作用: 数据访问层, 用来操作数据库表的数据
    db数据库: 这里指MySQL
    domain 实体包: 存放JavaBean
    tools工具包:存放项目中使用到的工具类
    test 测试包: 存放项目功能测试的代码

    功能界面菜单
    这里写图片描述
    界面菜单的完成,是项目编写的第一步。
    我们通过输出语句,完成界面菜单的输出,之后再根据输入的功能序号,进行对应功能的调用执行。

    功能实现步骤
    1编写MainView类run方法
    1.1完成功能界面菜单显示
    1.2接收键盘输入的功能选项
    1.3根据选项值,调用对应的功能方法
    2编写MainApp类的main主方法
    2.1调用MainView类中run方法,实现将程序执行起来,显示功能界面菜单。

    MainApp.java

    package cn.ctgu.gjp.app;
    
    import cn.ctgu.gjp.view.MainView;
    
    /*
     * 主程序类:开启软件安程序
     * */
    public class MainApp {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            new MainView().run();
        }
    
    }

    MainView.java

    package cn.ctgu.gjp.view;
    
    import java.util.List;
    import java.util.Scanner;
    
    import cn.ctgu.gjp.controller.ZhangWuController;
    import cn.ctgu.gjp.domain.ZhangWu;
    
    /*
     * 视图层,用户看到和操作的界面
     * 数据传递给controller层实现
     * 成员位置:创建controller对象
     * 
     * */
    public class MainView {
        private ZhangWuController controller=new ZhangWuController();
        /*
         * 实现界面效果
         * 接收用户的输入
         * 根据数据,调用不同的功能方法
         * 
         * */
        public void run() {
            /*
             * 创建Scanner类对象,反复键盘输入
             * */
            Scanner sc=new Scanner(System.in);
            while(true) {
                System.out.println("-------管家婆家庭记账软件--------");
                System.out.println("1.添加账务 2.编辑账务 3.删除账务 4.查询账务 5.退出系统");
                System.out.println("请输入要操作的功能序号[1-5]:");
                //接受用户的菜单选择
                int choose=sc.nextInt();
                //对选择的菜单判断,调用不同的功能
                switch(choose) {
                case 1:
                    //选择添加账务,调用添加账务的方法
                    addZhangWu();
                    break;
                case 2:
                    //选择编辑账务,调用编辑账务的方法
                    editZhangWu();
                    break;
                case 3:
                    //选择删除账务,调用删除账务的方法
                    deleteZhangWu();
                    break;
                case 4:
                    //选择查询账务,调用查询账务的方法
                    selectZhangWu();
                    break;
                case 5:
                    System.exit(0);
                    break;
    
                }
            }
        }
    
        /*
         * 定义方法实现对账务的删除
         * 实现思想:
         *  接收用户的输入,输入一个主键数据
         *  调用控制层,传递一个主键
         * 
         * */
        public void deleteZhangWu() {
            //调用查询所有账务数据的功能,显示出来
                    //看到所有数据,从中选择一项进行修改
            selectAll();
            System.out.println("选择的是删除功能,请输入ID号:");
            int zwid=new Scanner(System.in).nextInt();
            //调用控制层方法,传递主键id即可
            controller.deleteZhangWu(zwid);
            System.out.println("删除账务成功");
        }
    
        /*
         * 定义方法,实现对账务的编辑功能
         * 实现思想:
         *      接收用户的输入
         *      数据的信息,封装成ZhangWu对象
         *      调用控制层的方法,传递ZhangWu对象,实现编辑
         * 
         * */
        public void editZhangWu() {
            //调用查询所有账务数据的功能,显示出来
            //看到所有数据,从中选择一项进行修改
            selectAll();
            System.out.println("选择的是编辑功能,请输入数据");
            Scanner sc=new Scanner(System.in);
            //接收用户的数据
            System.out.println("输入ID:");
            int zwid=sc.nextInt();
            System.out.println("输入分类名称:");
            String flname=sc.next();
            System.out.println("输入金额:");
            double money=sc.nextDouble();
            System.out.println("输入账户:");
            String zhanghu=sc.next();
            System.out.println("输入日期:格式XXX-XX-XX");
            String createtime=sc.next();
            System.out.println("输入具体描述:");
            String description=sc.next();
            //将所有用户输入的数据封装到ZhangWu对象中
            //输入的ID,必须封装对象
            ZhangWu zw=new ZhangWu(zwid, flname, money, zhanghu, createtime, description);
            //调用controller层中的方法,实现编辑账务
            controller.editZhangWu(zw);
            System.out.println("账务编辑成功!");
    
        }
    
    
        /*
         * 定义方法 addZhangWu
         * 添加账务的方法,用户在界面中选择菜单1的时候调用
         * 实现思想:
         *  接收键盘输入,5项输入,调用controller层方法
         * */
        public void addZhangWu() {
            System.out.println("选择的添加账务功能,请输入一下内容");
            Scanner sc=new Scanner(System.in);
            System.out.println("输入分类名称:");
            String flname=sc.next();
            System.out.println("输入金额:");
            double money=sc.nextDouble();
            System.out.println("输入账户:");
            String zhanghu=sc.next();
            System.out.println("输入日期:格式XXX-XX-XX");
            String createtime=sc.next();
            System.out.println("输入具体描述:");
            String description=sc.next();
            //将接收到的数据调用controller层的方法,传递参数实现数据添加
            ZhangWu zw=new ZhangWu(0, flname, money, zhanghu, createtime, description);
            controller.addZhangWu(zw);
            System.out.println("添加账务成功!");
        }
    
        /*
         * 定义方法selectZhangWu()
         * 显示查询的方式1所有查询   2条件查询
         * 
         * */
        public void selectZhangWu() {
            System.out.println("1.查询所有    2.条件查询");
            Scanner sc=new Scanner(System.in);
            int selectChooser=sc.nextInt();
            //判断根据用户的选择,调用不同的功能
            switch(selectChooser) {
            case 1:
                //选择的查询所有,调用查询所有的方法
                selectAll();
                break;
            case 2:
                //选择条件查询,调用带有查询条件的方法
                select();
                break;
            }
        }
        /*
         * 定义方法实现查询所有的账务数据
         * */
        public void selectAll() {
            //调用控制层中的方法,查询所有的账务数据
            List<ZhangWu>list=controller.selectAll();
            print(list);
    
        }
    
        /*
         * 定义方法实现条件查询账务数据
         * 提供用户的输入日期,开始日期结束日期
         * 就2个日期,传递到controller层
         * 调用controller的方法,传递2个日期参数
         * 获取到controller查询的结果集,打印出来
         * */
        public void select() {
            System.out.println("选择条件查询,输入日期格式XXXX-XX-XX");
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入开始日期:");
            String startDate=sc.nextLine();
            System.out.println("请输入结束日期:");
            String endDate=sc.nextLine();
            //调用controller层的方法,传递日期,获取查询结果集
            List<ZhangWu>list=controller.select(startDate, endDate);
            if(list.size()!=0)
                print(list);
            else
                System.out.println("没有查询到数据");
        }
        //输出账务数据方法,接收List集合,遍历集合,输出表格
        private void print(List<ZhangWu> list) {
            //输出表头
            System.out.println("ID\t类别\t账户\t金额\t时间\t说明");
            //遍历集合,结果输出控制台
            for(ZhangWu zw:list) {
                System.out.println(zw.getZwid()+"\t"+zw.getFlname()+"\t"+zw.getZhanghu()+"\t"+
            zw.getMoney()+"\t"+zw.getCreatetime()+"\t"+zw.getDescription());
            }
        }
    }

    查询所有账务
    这里写图片描述
    功能实现步骤
    1编写MainView类中selectZhangWu方法
    1.1通过输出语句,显示出要查询账务的方式
    1.2接收键盘的输入项,调用对应的方法(1.查询所有 2.按条件查询)
    2编写MainView类中selectAll查询所有账务方法
    2.1调用ZhangWuService类selectAll方法,返回包含所有账务数据的List集合
    2.2调用MainView类中print方法,实现控制台显示所有账务数据
    3编写MainView类中print方法
    3.1使用输出语句,打印出账务表的表头名称
    这里写图片描述
    3.2遍历账务集合,将每个账务信息输出打印
    4编写ZhangWuService类中selectAll方法
    4.1调用ZhangWuDao类中selectAll方法,返回包含所有账务数据的List集合
    5编写ZhangWuDao类中selectAll()方法
    5.1通过QueryRunner对象,调用query方法查询数据库表gjp_zhangwu,返回包含所有账务数据的List集合

    多条件查询账务
    这里写图片描述
    功能分析
    1编写MainView类中select方法
    1.1通过键盘输入查询日期的范围
    1.2调用ZhangWuSerice类中select方法,返回查询日期范围内的账务信息集合List
    1.3调用MainView类中的print方法,将账务信息集合中的内容显示在控制台中
    2编写ZhangWuService类中select方法
    2.1调用ZhangWuDao 类中select方法,返回查询日期范围内的账务信息集合List
    3编写ZhangWuDao类中select方法
    通过QueryRunner对象,调用query方法查询数据库表gjp_zhangwu,返回包含查询日期范围内的账务数据List集合

    ZhangWuService.java

    package cn.ctgu.gjp.service;
    
    import java.util.List;
    
    import cn.ctgu.gjp.dao.ZhangWuDao;
    import cn.ctgu.gjp.domain.ZhangWu;
    
    /*
     * 业务层类
     * 接收上一层,控制层controller的数据
     * 经过计算,传递给dao层,操作数据库
     * 调用dao层中的类,类成员位置,创建dao类对象
     * 
     * */
    public class ZhangWuService {
        private ZhangWuDao dao=new ZhangWuDao();
    
        /*
         * 定义方法,实现编辑账务
         * 由控制层调用,传递ZhangWu对象
         * 调用dao层的方法,传递ZhangWu对象
         * */
        public void editZhangWu(ZhangWu zw) {
            dao.editZhangWu(zw);
        }
    
        /*
         * 定义方法,实现添加账务 
         * 是由控制层调用,传递ZhangWu类型对象
         * 调用dao层方法,传递ZhangWu对象
         * 
         * */
        public void addZhangWu(ZhangWu zw) {
            dao.addZhangWu(zw);
        }
    
        /*
         * 定义方法,实现条件查询账务
         * 方法由控制层调用,传递2个日期字符串
         * 调用dao层的方法,传递2个日期字符串
         * 获取到查询结果集
         * 
         * */
        public List<ZhangWu>select(String startDate,String endDate){
            return dao.select(startDate,endDate);
        }
    
    
        /*
         * 定义方法,实现查询所有的账务数据
         * 此方法由控制层调用,去调用dao层的方法
         * 返回存储账务的list集合
         * */
        public List<ZhangWu> selectAll() {
            return dao.selectAll();
    
        }
    
        public void deleteZhangWu(int zwid) {
            // TODO Auto-generated method stub
            dao.deleteZhangWu(zwid);
        }
    }

    ZhangWuDao.java

    package cn.ctgu.gjp.dao;
    
    import java.sql.SQLException;
    import java.util.List;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    
    import cn.ctgu.gjp.domain.ZhangWu;
    import cn.ctgu.gjp.tools.JDBCUtils;
    
    /*
     * 实现对数据表gjp_zhangwu数据增删改查操作
     * dbutils工具类完成,类成员创建QueryRunnner对象,指定数据源
     * 
     * */
    public class ZhangWuDao {
        private QueryRunner qr=new QueryRunner(JDBCUtils.getDataSource());
    
        /*
         * 定义方法,实现添加账务功能
         * 由业务层调用,传递ZhangWu对象
         * 将ZhangWu对象中的数据,添加到数据表
         * */
        public void addZhangWu(ZhangWu zw) {
            try {
                //拼写添加数据的sql
                String sql="INSERT INTO gjp_zhangwu(flname,money,zhanghu,createtime,description)VALUES(?,?,?,?,?)";
                //创建对象数组,存储5个占位符的实际参数
                //实际参数来源是传递过来的对象的ZhangWu
                Object[]params= {zw.getFlname(),zw.getMoney(),zw.getZhanghu(),zw.getCreatetime(),zw.getDescription()};
                //调用qr对象中的方法update执行添加
                qr.update(sql,params);
            }catch(SQLException e) {
                System.out.println(e);
                throw new RuntimeException("账务添加失败");
            }
        }
    
        /*
         * 定义方法,查询数据库,带有条件去查询账务表
         * 由业务层调用,查询结果集存储到Bean对象,存储到List集合
         * 调用者传递2个日期字符串
         * 
         * */
        public List<ZhangWu>select(String startDate,String endDate){
            try {
                //拼写条件查询的sql语句
                String sql="SELECT * FROM gjp_zhangwu WHERE createtime BETWEEN ? AND ?";
                //定义对象数组,存储?占位符
                Object[]params= {startDate,endDate};
                //调用qr对象的方法query查询数据表,获取结果集
                return qr.query(sql, new BeanListHandler<ZhangWu>(ZhangWu.class),params);
            }catch(SQLException e) {
                System.out.println(e);
                throw new RuntimeException("条件查询失败");
    
            }
        }
    
        /*
         * 定义方法,查询数据库,获取所有的账务数据
         * 方法由业务层调用
         * 结果集将所有的账务数据存储到Bean对象中,然后存储到集合中
         * 
         * */
        public List<ZhangWu> selectAll() {
            try {
                //查询账务数据的sql语句
                String sql="SELECT * FROM gjp_zhangwu";
                //调用qr对象的方法,query方法,结果集BeanListHandler
                List<ZhangWu>list=qr.query(sql, new BeanListHandler<>(ZhangWu.class));
                return list;
            }catch(Exception e) {
                System.out.println(e);
                throw new RuntimeException("查询所有账务失败");
            }
        }
    
        /*
         * 定义方法实现编辑账务功能
         * 由业务层调用传递ZhangWu对象
         * 将对象中的数据更新到数据表
         * */
        public void editZhangWu(ZhangWu zw) {
            // TODO Auto-generated method stub
            try {
                //更新数据的sql
                String sql="UPDATE gjp_zhangwu SET flname=?,money=?,"
                        + "zhanghu=?,createtime=?,description=? WHERE zwid=?";
                //定义对象数组,将所有的参数放进去
                Object[]params= {zw.getZwid(),zw.getFlname(),zw.getMoney(),zw.getZhanghu(),zw.getCreatetime(),zw.getDescription()};
                //调用qr对象方法update执行更新
                qr.update(sql,params);
            }catch(SQLException e) {
                System.out.println(e);
                throw new RuntimeException("账务编辑失败");
            }
        }
    
        public void deleteZhangWu(int zwid) {
            // TODO Auto-generated method stub
            try {
                //删除数据的sql
                String sql="DELETE FROM gjp_zhangwu WHERE zwid=?";
                qr.update(sql,zwid);
            }catch(SQLException e) {
                System.out.println(e);
                throw new RuntimeException("删除账务失败");
            }
        }
    }

    添加账务
    这里写图片描述
    功能分析
    1编写MainView类中addZhangWu方法
    1.1键盘输入新添加的账务信息
    1.2调用ZhangWuService类中addZhangWu方法,用来指定账务的添加
    1.3添加完毕后,使用输出语句,提示“添加账务成功!”
    2编写ZhangWuService类中addZhangWu方法
    2.1调用ZhangWuDao类中addZhangWu方法,用来指定账务的添加
    3编写ZhangWuDao类中addZhangWu方法
    3.1通过QueryRunner对象,调用update方法更新数据库表gjp_zhangwu,完成指定账务添加到数据库表中

    编辑账务
    这里写图片描述
    功能分析
    1编写MainView类中editZhangWu方法
    1.1键盘输入要编辑的账务信息ID号
    1.2键盘输入要修改的账务信息内容
    1.3调用ZhangWuService类中editZhangWu方法,用来将指定的账务信息进行更新
    1.4更新完毕后,使用输出语句,提示 “编辑账务成功!”
    2编写ZhangWuService类中editZhangWu方法
    2.1调用ZhangWuDao类中editZhangWu方法,用来将指定的账务信息进行更新
    3编写ZhangWuDao类中editZhangWu方法
    3.1通过QueryRunner对象,调用update方法更新数据库表gjp_zhangwu,完成数据库表中指定账务更新操作

    删除账务
    这里写图片描述

    功能分析
    1编写MainView类中deleteZhangWu方法
    1.1键盘输入要删除的账务信息ID号
    1.2调用ZhangWuService类中deleteZhangWu方法,用来将指定的账务信息删除
    1.3删除完毕后,使用输出语句,提示 “删除账务成功!”
    2编写ZhangWuService类中deleteZhangWu方法
    2.1调用ZhangWuDao类中deleteZhangWu方法,用来将指定的账务信息删除
    3编写ZhangWuDao类中deleteZhangWu方法
    3.1通过QueryRunner对象,调用update方法更新数据库表gjp_zhangwu,完成数据库表中指定账务删除操作

    其他代码:
    ZhangWuController.java

    package cn.ctgu.gjp.controller;
    
    import java.util.List;
    
    import cn.ctgu.gjp.domain.ZhangWu;
    import cn.ctgu.gjp.service.ZhangWuService;
    
    /*
     * 控制器层
     * 接收视图层的数据,数据传递给service层
     * 成员位置,创建安service对象
     * 
     * 
     * */
    public class ZhangWuController {
        private ZhangWuService service=new ZhangWuService();
    
        /*
         * 定义方法实现删除功能
         *     由视图层调用,传递int类型主键
         *     调用service层方法,传递int主键
         * 
         * */
        public void deleteZhangWu(int zwid) {
            service.deleteZhangWu(zwid);
        }
    
        /*
         * 定义方法实现编辑账务功能
         * 由视图层调用,传递参数,也是ZhangWu对象
         * 调用Service层的方法,传递ZhangWu对象
         * */
        public void editZhangWu(ZhangWu zw) {
            service.editZhangWu(zw);
        }
    
        /*
         * 定义方法,实现账务添加功能
         * 由视图层调用,传递参数(传递过来的参数不能是5个数据,传递的是1个ZhangWu类型的对象)
         * 方法调用service层的方法,传递ZhangWu对象,获取到添加后的结果集(添加成功的行数 int)
         * */
        public void addZhangWu(ZhangWu zw) {
            service.addZhangWu(zw);
        }
    
        /*
         * 定义方法,实现条件查询账务
         * 方法由视图层调用,传递两个日期的字符串
         * 调用service层的方法,传递两个日期字符串,获取结果集
         * 结果集返回给视图
         * 
         * 
         * */
        public List<ZhangWu>select(String startDate,String endDate){
            return service.select(startDate, endDate);
        }
    
        /*
         * 控制层类定义方法,实现查询所有的账务数据
         * 方法由视图层调用,方法调用service层
         * */
        public List<ZhangWu> selectAll() {
            return service.selectAll();
        }
    }

    ZhangWu.java(domain包中的JavaBean)

    package cn.ctgu.gjp.domain;
    
    public class ZhangWu {
    
        private int zwid;
    
        private String flname;
    
        private double money; 
    
        private String zhanghu; 
    
        private String createtime;
        private String description;
        public ZhangWu(int zwid, String flname, double money, String zhanghu, String createtime, String description) {
            super();
            this.zwid = zwid;
            this.flname = flname;
            this.money = money;
            this.zhanghu = zhanghu;
            this.createtime = createtime;
            this.description = description;
        }
        public int getZwid() {
            return zwid;
        }
        public void setZwid(int zwid) {
            this.zwid = zwid;
        }
        public String getFlname() {
            return flname;
        }
        public void setFlname(String flname) {
            this.flname = flname;
        }
        public double getMoney() {
            return money;
        }
        public void setMoney(double money) {
            this.money = money;
        }
        public String getZhanghu() {
            return zhanghu;
        }
        public void setZhanghu(String zhanghu) {
            this.zhanghu = zhanghu;
        }
        public String getCreatetime() {
            return createtime;
        }
        public void setCreatetime(String createtime) {
            this.createtime = createtime;
        }
        public String getDescription() {
            return description;
        }
        public void setDescription(String description) {
            this.description = description;
        }
        public ZhangWu() {
            super();
            // TODO Auto-generated constructor stub
        }
        @Override
        public String toString() {
            return "Zhangwu [zwid=" + zwid + ", flname=" + flname + ", money=" + money + ", zhanghu=" + zhanghu
                    + ", createtime=" + createtime + ", description=" + description + "]";
        } 
    
    
    }

    JDBCUtils.java(tools包中的工具类)

    package cn.ctgu.gjp.domain;
    
    public class ZhangWu {
    
        private int zwid;
    
        private String flname;
    
        private double money; 
    
        private String zhanghu; 
    
        private String createtime;
        private String description;
        public ZhangWu(int zwid, String flname, double money, String zhanghu, String createtime, String description) {
            super();
            this.zwid = zwid;
            this.flname = flname;
            this.money = money;
            this.zhanghu = zhanghu;
            this.createtime = createtime;
            this.description = description;
        }
        public int getZwid() {
            return zwid;
        }
        public void setZwid(int zwid) {
            this.zwid = zwid;
        }
        public String getFlname() {
            return flname;
        }
        public void setFlname(String flname) {
            this.flname = flname;
        }
        public double getMoney() {
            return money;
        }
        public void setMoney(double money) {
            this.money = money;
        }
        public String getZhanghu() {
            return zhanghu;
        }
        public void setZhanghu(String zhanghu) {
            this.zhanghu = zhanghu;
        }
        public String getCreatetime() {
            return createtime;
        }
        public void setCreatetime(String createtime) {
            this.createtime = createtime;
        }
        public String getDescription() {
            return description;
        }
        public void setDescription(String description) {
            this.description = description;
        }
        public ZhangWu() {
            super();
            // TODO Auto-generated constructor stub
        }
        @Override
        public String toString() {
            return "Zhangwu [zwid=" + zwid + ", flname=" + flname + ", money=" + money + ", zhanghu=" + zhanghu
                    + ", createtime=" + createtime + ", description=" + description + "]";
        } 
    
    
    }

    5.5 数据库的事务
    1、什么是事务?
    一件事情有n个组成单元,要不这个n个组成单元同时成功,要不n个单元就同时失败
    也就是将n个组成单元放到一个事务中。
    2、Mysql的事务
    默认的事务:一条sql语句就是一个事务,默认就开启事务并提交事务
    手动事务:
    1、显示的开启一个事务:start transaction
    2、事务提交:commit代表从开启事务到事务提交中间的所有的sql都认为有效

    真正的更新事务:
    3、事务的回滚:rollback代表事物的回滚,从开启事务到事务回滚,中间的所有的
    sql操作都认为无效数据库,即没有被更新
    

    总结:
    Mysql的事务控制:
    开启事务:start transaction
    提交事务:commit
    回滚事务:rollback

    JDBC事务控制:
        开启事务:conn.setAutoCommit(false);
        提交事务:conn.commit();
        回滚事务:conn.rollback()
    
    DBUtils的事务控制也是通过jdbc
    ThreadLocal:实现的是通过线程绑定的方式传递参数
    

    1.事务的特性ACID
    1)原子性(Atomicity)原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
    2)一致性(Consistency)一个事务中,事务前后数据的完整性必须保持一致。
    3)隔离性(Isolation)多个事务,事务的隔离性是指多个用户并发访问数据库时,一个用户的 事务不能被其它用户的事务所干扰,多个并发事务之间数据要相互隔离。
    4)持久性(Durability)持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响。
    2.并发访问问题—-由隔离性引起
    如果不考虑隔离性,事务存在3中并发访问问题。
    1)脏读:B事务读取到了A事务尚未提交的数据 —— 要求B事务要读取A事 务提交的数据
    2)不可重复读:一个事务中 两次读取的数据的内容不一致 —– 要求的是一个事 务中多次读取时数据是一致的 — unpdate
    3)幻读/虚读:一个事务中 两次读取的数据的数量不一致 —– 要求在一个事务多 次读取的数据的数量是一致的 –insert delete
    3.事务的隔离级别
    1)read uncommitted : 读取尚未提交的数据 :哪个问题都不能解决
    2)read committed:读取已经提交的数据 :可以解决脏读 —- oracle默认的
    3)repeatable read:重读读取:可以解决脏读 和 不可重复读 —mysql默认的
    serializable:串行化:可以解决 脏读 不可重复读 和 虚读—相当于锁表

    查看mysql数据库默认的隔离级别:select @@tx_isolation
    这里写图片描述

    设置mysql的隔离级别:set session transaction isolation level 设置事务隔离级别
    这里写图片描述

    隔离级别的性能:
    read uncommitted>read committed>repeatable read>serialazable

    安全性:read uncommitted<read committed<repeatable read<serialazable

    JDBC控制事务

    package cn.itcast.jdbc;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    
    
    public class JDBCDemo {
        public static void main(String[] args) {
    
            //通过jdbc去控制事务
            Connection conn=null;
            try {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、获得Connection
            conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/mybase", "root", "123456");
            //手动开启事务
            conn.setAutoCommit(false);//手动提交
            //3、获得执行平台
            Statement stmt=conn.createStatement();
            //4、操作sql
            stmt.executeUpdate("insert into product values(9,'早餐','25','吃早饭')");
            //提交事务
            //执行sql的connection与开启事务的connection必须是同一个才能对事务进行控制
            conn.commit();
    
            stmt.close();
            conn.close();
            }catch(Exception e) {
                try {
                    conn.rollback();
                } catch (SQLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        }
    }

    DBUtils工具控制事务

    package cn.itcast.jdbc;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.QueryRunner;
    
    import cn.itcast.demo3.JDBCUtils1;
    import cn.itcast.jdbcutil.JDBCUtilsConfig;
    
    public class DBUtilsDemo {
        public static void main(String[] args) {
            Connection conn=null;
            try {
            QueryRunner qr=new QueryRunner();
            //获得一个Connection
            conn=JDBCUtilsConfig.getConnection();
            //开启事务
            conn.setAutoCommit(false);
            qr.update(conn, "update product set sprice=100 where sid=8");
            //提交回滚事务
            conn.commit();
            }catch(SQLException e) {
                try {
                    conn.rollback();
                }catch(SQLException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    事务隔离案例——转账

    transfer.jsp

    <%@ page language="java" contentType="text/html; charset=utf-8"
        pageEncoding="utf-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Insert title here</title>
    </head>
    <body>
        <form action="${pageContext.request.contextPath }/transferServlet" method="post">
            转出账户:<input type="text" name="out"/><br/>
            转入账户:<input type="text" name="in"/><br/>
            转账金额:<input type="text" name="money"/>
            <input type="submit" value="确认转账"/>
        </form>
    </body>
    </html>

    transferServlet.java

    package cn.ctgu.web;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import cn.ctgu.service.TransferService;
    
    /**
     * Servlet implementation class transferServlet
     */
    @WebServlet("/transferServlet")
    public class transferServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        /**
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
         */
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            //接收转账的参数
            String out=request.getParameter("out");
            String in=request.getParameter("in");
            String moneyStr=request.getParameter("money");
            double money=Double.parseDouble(moneyStr);
    
            //调用业务层的转账方法
            TransferService service=new TransferService();
            boolean isTransferSuccess=service.transfer(out,in,money);
    
            response.setContentType("text/html;charset=utf-8");
            if(isTransferSuccess) {
                response.getWriter().write("转账成功!!!");
            }else {
                response.getWriter().write("转账失败!!!");
            }
    
    
    
        }
    
        /**
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
         */
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            // TODO Auto-generated method stub
            doGet(request, response);
        }
    
    }

    TransferService.java

    package cn.ctgu.service;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    
    import cn.ctgu.dao.JDBCUtils;
    import cn.ctgu.dao.TransferDao;
    
    
    public class TransferService {
        public boolean transfer(String out,String in,double money) {
            boolean transfersuccess=true;
            TransferDao dao=new TransferDao();
            Connection conn=null;
            try {
            conn=JDBCUtils.getConnection();
            //开启事务
            conn.setAutoCommit(false);
            //转入账户
            dao.out(conn,out,money);
            //转出账户
            dao.in(conn,in,money);
            }catch(Exception e) {
                transfersuccess=false;
                //回滚事务
                try {
                    conn.rollback();
                } catch (SQLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                    throw new RuntimeException("转账失败");
                }
            }
            finally {
                    try {
                        conn.commit();//提交事务
                    } catch (SQLException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                        throw new RuntimeException("转账失败");
                    }
                }
                return transfersuccess;
            }
    
        }
    

    TransferDao.java

    package cn.ctgu.dao;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.QueryRunner;
    
    public class TransferDao {
         public void out(Connection conn,String out,double money) throws SQLException {
             QueryRunner qr=new QueryRunner();
             Object[]params= {money,out};
             String sql= "UPDATE counts SET money=money-? WHERE cname=?";
             qr.update(conn,sql,params);
         }
         public void in(Connection conn,String in,double money) throws SQLException {
             QueryRunner qr=new QueryRunner();
             Object[]params= {money,in};
             String sql="UPDATE counts SET money=money+? WHERE cname=?";
             qr.update(conn,sql,params);
         }
    }

    通过 ThreadLocal改进的代码(推荐这种)
    这里写图片描述
    TransferService2.java

    package cn.ctgu.service;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    
    import cn.ctgu.dao.JDBCUtils;
    import cn.ctgu.dao.MyDataSourceUtils;
    import cn.ctgu.dao.TransferDao2;
    
    
    public class TransferService2 {
        public boolean transfer(String out,String in,double money) {
            boolean transfersuccess=true;
            TransferDao2 dao=new TransferDao2();
    
            try {
            //开启事务
            MyDataSourceUtils.startTransaction();
    
    
            //转入账户
            dao.out(out,money);
            //转出账户
            dao.in(in,money);
            }catch(Exception e) {
                transfersuccess=false;
                //回滚事务
                try {
                    MyDataSourceUtils.rollback();
                } catch (SQLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                    throw new RuntimeException("转账失败");
                }
            }
            finally {
                    try {
                        MyDataSourceUtils.commit();//提交事务
                    } catch (SQLException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                        throw new RuntimeException("转账失败");
                    }
                }
                return transfersuccess;
            }
    
        }
    

    MyDataSourceUtils.java(关键代码,将一个连接放到一个线程中)

    package cn.ctgu.dao;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    public class MyDataSourceUtils {
        //获得Connection  从连接池中获取
        private static ComboPooledDataSource dataSource=new ComboPooledDataSource();
        //创建ThreadLocal
        private static ThreadLocal<Connection> tl=new ThreadLocal<Connection>();
    
        //开启事务
        public static void startTransaction() throws SQLException {
            Connection conn=getCurrentConnection();
            conn.setAutoCommit(false);
        }
    
    
        //获得当前线程绑定的conn
        public static Connection getCurrentConnection() throws SQLException {
            //从ThreadLocal寻找当前线程是否有对应Connection
            Connection conn=tl.get();
            if(conn==null) {
                //获得新的connection
                conn= getConnection();
                //将conn资源绑定到ThreadLocal(map)上
                tl.set(conn);
            }
            return conn;
        }
    
        public static Connection getConnection() throws SQLException {
            return dataSource.getConnection();
        }
    
        //回滚事务
        public static void rollback() throws SQLException {
            // TODO Auto-generated method stub
            getCurrentConnection().rollback();
        }
    
        //提交事务
        public static void commit() throws SQLException {
            // TODO Auto-generated method stub
            Connection conn=getCurrentConnection();
            conn.commit();
            //将Connection从ThreadLocal中移除
            tl.remove();
            conn.close();
        }
    
    }
    

    TransferDao2.java

    package cn.ctgu.dao;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    import org.apache.commons.dbutils.QueryRunner;
    
    public class TransferDao2 {
         public void out(String out,double money) throws SQLException {
             QueryRunner qr=new QueryRunner();
             Connection conn=MyDataSourceUtils.getCurrentConnection();
             Object[]params= {money,out};
             String sql= "UPDATE counts SET money=money-? WHERE cname=?";
             qr.update(conn,sql,params);
         }
         public void in(String in,double money) throws SQLException {
             QueryRunner qr=new QueryRunner();
             Connection conn=MyDataSourceUtils.getCurrentConnection();
             Object[]params= {money,in};
             String sql="UPDATE counts SET money=money+? WHERE cname=?";
             qr.update(conn,sql,params);
         }
    }
    展开全文
  • JavaWeb连接数据库增删改查(含登录验证、分页)

    万次阅读 多人点赞 2018-10-29 17:15:38
    简单的页面对数据库的增删改查——新手入门推举 一、准备工作 eclipse(无版本要求)或myeclipse都行,本人用的是eclipse Apache Tomcat,我用的是7.0版本 数据库 MySQL 需要掌握到的知识点:项目的基本框架...

    简单的页面对数据库的增删改查——新手入门推举

    一、准备工作

    • eclipse(无版本要求)或myeclipse都行,本人用的是eclipse
    • Apache Tomcat,我用的是7.0版本
    • 数据库 MySQL
    • 需要掌握到的知识点:项目的基本框架搭建(经典三层框架
      在这里插入图片描述

    二、项目的基本框架搭建

    三层框架分别为:表现层、业务逻辑层、数据访问层。

    • 表现层:包含JSP和Servlet等与web相关的内容,负责与浏览器的响应和请求;
    • 业务层:只关心业务逻辑;
    • 数据层:封装了对数据库的访问细节,数据操作类;

    三层关系:表现层依赖业务层,而业务层依赖数据层

    三、实现数据库的连接

    需要在MySQL中创建所需数据库,并将表建好。

    1. 数据库名为test
    2. 项目信息表名为User,表结构如下,其中id为自增长主键,增量为1。
      在这里插入图片描述

    四、代码实现

    1、在Util包下新建一个JDBCUtil 类用来处理对数据进行连接

    package Util;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    public class JDBCUtil {
    	private static String DBDriver="org.gjt.mm.mysql.Driver";
    	private static String url="jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8";
    	private static String user="root";
    	private static String password="root";
    	static Connection con=null;
    	static Statement sta=null;
    	static PreparedStatement psta=null;
    	//获得数据库的链接
    	public static Connection getConnection()
    	{
    		try {
    			Class.forName(DBDriver);
    			try {
    				con = DriverManager.getConnection(url, user, password);
    				return con;
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		} catch (ClassNotFoundException e1) {
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		}
    
    		return null;
    	}
    	public static Statement createStatement()
    	{
    		try {
    			sta=getConnection().createStatement();
    			return sta;
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    	//创造数据预处理对象
    	public static PreparedStatement createPreparedStatement(String sql)
    	{
    		try {
    			psta = getConnection().prepareStatement(sql);
    			return psta;
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return psta;
    	}
    	//关闭所有打开的资源
    	public static void closeOperation()
    	{
    		if(psta==null)
    		{
    			try {
    				psta.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if(sta==null)
    		{
    			try {
    				sta.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if(con==null)
    		{
    			try {
    				con.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    
    	}
    }
    
    

    2、在Model包下创建User实体类(实体类中的对象对应数据库表中的字段数据)

    package Model;
    
    //类的设计
    public class User {
    	private int id;
    	private String userName;
    	private String password;
    	private String Email;
    	
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	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;
    	}
    	public String getEmail() {
    		return Email;
    	}
    	public void setEmail(String email) {
    		Email = email;
    	}
    
    }
    

    3、在Dao包下创建UserDao实现对数据库的增删改查方法

    package Dao;
    
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import Model.User;
    import Util.MysqlHelper;
    
    public class UserDao {
    	public boolean Login(String userName,String password){
    		String sql="select userName,password from User ";
    		ResultSet rs=MysqlHelper.executeQuery(sql);
    		try {
    			while(rs.next()){               //用户输入的信息和数据库中的信息做比较,判断输入是否正确;  
    			    String name = rs.getString("userName");  
    			    String pwd = rs.getString("password");  
    			    if(name.equals(userName) && pwd.equals(Util.MD5Helper.GetMD5Code(password))){
    			        return true;  
    			    }   
    			}
    			rs.close();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return false;
    	}
    	public void addUser(User u)
    	{
    		String sql="insert into User (userName,password,Email) values (?,?,?)";
    		Util.MysqlHelper.executeUpdate(sql, u.getUserName(),Util.MD5Helper.GetMD5Code(u.getPassword()),u.getEmail());
    	}
    	public void deleteUser(int i){
    		String sql = "delete from user where id=?";
    		Util.MysqlHelper.executeUpdate(sql,i);
    	}
    	public void modifyUser(User u){
    		String sql = "update User set id=?,userName=?,Email=? where id=? ";
    		Util.MysqlHelper.executeUpdate(sql,u.getId(),u.getUserName(),u.getEmail(),u.getId());
    	}
    	public void deleteUserByUserName(String userName)
    	{
    		
    	}
    	public void updateUser(Object...objects)
    	{
    		
    	}
    	//根据用户名查询到一个User对象,然后返回User对象
    	public User QueryUserByUserName(String userName)
    	{
    		User u=new User();
    		String sql="select * from User where userName=?";
    		ResultSet rs=MysqlHelper.executeQuery(sql, userName);
    		try {
    			if(rs.next())
    			{
    				u.setId(Integer.parseInt(rs.getObject("id").toString()));
    				u.setUserName(rs.getString("userName"));
    				u.setEmail(rs.getString("Email"));
    				
    			}
    		} catch (NumberFormatException | SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return u;
    		
    	}
    	//查询所有用户信息
    	public List QueryUsers()
    	{
    		List<User> list=new ArrayList<User>();   //最终返回整个list集合
    		String sql="select * from user";
    		ResultSet rs=MysqlHelper.executeQuery(sql);
    		try {
    			while(rs.next())
    			{
    				//保存取出来的每一条记录
    				User u=new User();
    				u.setId(rs.getInt("id"));
    				u.setUserName(rs.getString("userName"));
    				u.setEmail(rs.getString("Email"));
    				list.add(u);				
    			}
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		return list;
    		
    	}
    }
    
    

    4、在Util包下创建MysqlHelper接收传递过来的参数

    package Util;
    
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class MysqlHelper {
    
    //执行增、删、改   用可变参数,来接收传递过来的参数,参数的个数可以不确定,提高使用率
    	public static int executeUpdate(String sql,Object...objects)
    	{
    		int len=0;
    		PreparedStatement psta=JDBCUtil.createPreparedStatement(sql);
    		
    			try {
    				for (int i = 0; i < objects.length; i++) {
    					psta.setObject(i+1, objects[i]);
    				}
    		len=psta.executeUpdate();
    		return len;
    				  //逐个对objects数组中的元素来进行设置 ,数组中一个元素对应一个问号
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} 	
    		
    		
    		return len;	
    		
    	}
    	//执行查询
    	public static ResultSet executeQuery(String sql,Object...objects)
    	{
    		ResultSet rs=null;
    		PreparedStatement psta=JDBCUtil.createPreparedStatement(sql);
    		try{
    		for (int i = 0; i < objects.length; i++) {
    			psta.setObject(i+1, objects[i]);
    		}
    			rs=psta.executeQuery();
    			return rs;
    		}catch(SQLException e)
    		{
    			e.printStackTrace();			
    		}finally{
    			//JDBCUtil.closeOperation();
    		}		
    		return rs;
    		
    	}
    
    }
    
    

    5、在BLL包下创建UserBLL传递参数调用增、删、改、查方法

    package BLL;
    
    import java.util.List;
    
    import Dao.UserDao;
    import Model.User;
    
    public class UserBLL {
    	public void addUser(User u) {
    		UserDao userdao = new UserDao();
    		userdao.addUser(u);
    	}
    
    	public boolean Login(String userName,String password){
    		return new UserDao().Login(userName,password);
    	}
    	
    	public void deleteUser(int i) {
    		UserDao userdao = new UserDao();
    		userdao.deleteUser(i);
    	}
    
    	public void modifyUser(User u) {
    		UserDao userdao = new UserDao();
    		userdao.modifyUser(u);
    	}
    
    	// 根据用户名查询到一个User对象,然后返回User对象
    	public User QueryUserByUserName(String userName) {
    		return new UserDao().QueryUserByUserName(userName);
    	}
    
    	public List QueryUsers() {
    		return new UserDao().QueryUsers();
    	}
    }
    
    

    6、在cn.UI包下创建Login用于登录验证

    package cn.UI;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import Model.User;
    
    public class Login extends HttpServlet{
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		this.doPost(req, resp);
    	}
    	@Override
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		request.setCharacterEncoding("gbk");
    		response.setCharacterEncoding("gbk");
    		String userName=request.getParameter("userName");
    		String passWord=request.getParameter("passWord");
    		if(new BLL.UserBLL().Login(userName, passWord)){
    			response.sendRedirect("show");
    		}
    		PrintWriter pw=response.getWriter();
    		pw.println("账户或密码错误!");
    		pw.flush();
    		pw.close();
    	}
    }
    
    

    7、创建分页查询类

    package cn.UI;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import Model.User;
    
    public class ShowData extends HttpServlet {
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		this.doPost(req, resp);
    	}
    	@Override
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		List list=new BLL.UserBLL().QueryUsers();
    		String pageIndex1=request.getParameter("pageIndex");
    		if(pageIndex1==null){
    			pageIndex1="0";
    		}
    		int pageIndex=Integer.parseInt(pageIndex1);  //拿到传递过来的请求的第几条记录
    		response.setCharacterEncoding("gbk");
    		PrintWriter pw=response.getWriter();
    		StringBuilder sb=new StringBuilder();  //字符串的缓存区
    		//int pageIndex=0;   //这是第几页
    		int pageSize=3;   //就是每一页要显示的数据总记录数
    		for(int j=0;j<list.size()/pageSize;j++)
    		{
    			sb.append("<a href='show?pageIndex="+j+"'>"+(j+1)+"</a>&nbsp&nbsp&nbsp");
    		}
    		for(int i=pageIndex*pageSize;i<(pageIndex+1)*pageSize;i++){
    			User u=(User)list.get(i);
    		sb.append("<html><head></head><body><table>");
    			sb.append("<tr><td>用户编号"+u.getId()+"</td>");
    			sb.append(String.format("<td>用户名%s</td>", u.getUserName()));
    			sb.append("<td>邮箱"+u.getEmail()+"</td>");
    			sb.append("<td><a href='add.html'>增加</a></td>");
    			sb.append("<td><a href='delete.html'>删除</a></td>");
    			sb.append("<td><a href='modifyData?userName="+u.getUserName()+"'>修改</a></td>");
    			sb.append("</tr>");
    			}
    		sb.append("</table></body></html>");
    		pw.write(sb.toString());
    		pw.flush();
    		pw.close();
    	}
    
    }
    

    8、增加类

    package cn.UI;
    
    import java.io.IOException;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import Model.User;
    
    public class AddUser extends HttpServlet{
    	
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		this.doPost(req, resp);
    	}
    	@Override
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		String userName=request.getParameter("userName");
    		String passWord=request.getParameter("passWord");
    		String Email=request.getParameter("Email");
    		User u=new User();
    		u.setUserName(userName);
    		u.setPassword(passWord);
    		u.setEmail(Email);
    		new BLL.UserBLL().addUser(u);
    		response.sendRedirect("show");
    	}
    }
    
    

    9、删除类

    package cn.UI;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class DeleteServlet extends HttpServlet {
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		this.doPost(req, resp);
    	}
    	@Override
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		request.setCharacterEncoding("gbk");
    		response.setCharacterEncoding("gbk");
    		PrintWriter pw=response.getWriter();
    		new BLL.UserBLL().deleteUser(Integer.parseInt(request.getParameter("id")));
    		response.sendRedirect("show");
    		pw.flush();
    		pw.close();
    	}
    
    }
    
    

    10、修改类一,获取当前用户数据值,便于操作者修改

    package cn.UI;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import Model.User;
    
    public class ModifyData extends HttpServlet{
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		this.doPost(req, resp);
    	}
    	@Override
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		response.setCharacterEncoding("gbk");
    		String userName=request.getParameter("userName");  //拿到要查询的id编号的数据
    		User u=new BLL.UserBLL().QueryUserByUserName(userName);
    		//展示u的数据,并显示出来
    		//读模板,然后替换特殊字符部分
    		BufferedReader br=new BufferedReader(new FileReader("E:\\Eclipse工作空间\\第二部\\ServiceJava\\WebContent\\modifyData.html"));
    		String s=br.readLine();
    		String context="";
    		while(s!=null)
    		{
    			context=context+s;
    			s=br.readLine();//读出所有的文本			
    		}
    		context=context.replace("@Id", u.getId()+"");   //替换字符串
    		context=context.replace("@userName", u.getUserName()).replace("@Email", u.getEmail());
    		PrintWriter pw=response.getWriter();
    		pw.println(context);
    		pw.flush();
    		pw.close();
    		
    		
    	}
    
    }
    
    

    11、修改类二

    package cn.UI;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import Model.User;
    
    public class UpdateData extends HttpServlet{
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		this.doPost(req, resp);
    	}
    	@Override
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		User u=new User();
    		request.setCharacterEncoding("gbk");
    		response.setCharacterEncoding("gbk");
    		int  id=Integer.valueOf(request.getParameter("id"));
    		String userName=request.getParameter("userName");
    		String Email=request.getParameter("Email");
    		u.setId(id);
    		u.setUserName(userName);
    		u.setEmail(Email);
    		new BLL.UserBLL().modifyUser(u);
    		response.sendRedirect("show");
    	}
    }
    
    

    PS:我这里加了一个MD5,加密了用户密码(可用可不用)

    package Util;
    
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class MD5Helper {
    	private static String bytesToHex(byte[] bytes) {
            StringBuffer md5str = new StringBuffer();
            //把数组每一字节换成16进制连成md5字符串
            int digital;
            for (int i = 0; i < bytes.length; i++) {
                 digital = bytes[i];
     
                if(digital < 0) {
                    digital += 256;
                }
                if(digital < 16){
                    md5str.append("0");
                }
                md5str.append(Integer.toHexString(digital));
            }
            return md5str.toString().toLowerCase();
        }
        public static String GetMD5Code(String strObj) {
            String resultString = null;
            try {
                resultString = new String(strObj);
                MessageDigest md = MessageDigest.getInstance("MD5");
                // md.digest() 该函数返回值为存放哈希值结果的byte数组
                byte b[]=md.digest(strObj.getBytes());
                resultString =bytesToHex(b) ;
            } catch (NoSuchAlgorithmException ex) {
                ex.printStackTrace();
            }
            return resultString;
        }
    
    }
    
    

    五、Web的配置

    <?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_2_5.xsd" id="WebApp_ID" version="2.5">
      <display-name>ServiceJava</display-name>
      <welcome-file-list>
      <welcome-file>login.html</welcome-file>
        <welcome-file>login.htm</welcome-file>
        <welcome-file>login.jsp</welcome-file>
        <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>
       <servlet>
      	<servlet-name>ShowData</servlet-name>
      	<servlet-class>cn.UI.ShowData</servlet-class>  
      </servlet>
      <servlet-mapping>
      	<servlet-name>ShowData</servlet-name>
      	<url-pattern>/show</url-pattern>
      </servlet-mapping>
      <servlet>
      	<servlet-name>AddUser</servlet-name>
        <servlet-class>cn.UI.AddUser</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>AddUser</servlet-name>
        <url-pattern>/addUser</url-pattern>
      </servlet-mapping>
      <servlet>
      	<servlet-name>Login</servlet-name>
        <servlet-class>cn.UI.Login</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>Login</servlet-name>
        <url-pattern>/login</url-pattern>
      </servlet-mapping>
       <servlet>
      	<servlet-name>DeleteServelet</servlet-name>
        <servlet-class>cn.UI.DeleteServlet</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>DeleteServelet</servlet-name>
        <url-pattern>/delete1</url-pattern>
      </servlet-mapping>
      <servlet>
      <servlet-name>modifyData</servlet-name>
      <servlet-class>cn.UI.ModifyData</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>modifyData</servlet-name>
      	<url-pattern>/modifyData</url-pattern>
      </servlet-mapping>
        <servlet>
      <servlet-name>UpdateData</servlet-name>
      <servlet-class>cn.UI.UpdateData</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>UpdateData</servlet-name>
      	<url-pattern>/upDate</url-pattern>
      </servlet-mapping>
    </web-app>
    

    六、HTML页面代码部分

    1、增

    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <form action="addUser" method="post">
    <table>
    	<tr><td>用户名</td><td><input type="text" name="userName"></td></tr>
        <tr><td>密码</td><td><input type="password" name="passWord"></td></tr>
        <tr><td>Email</td><td><input type="text" name="Email"></td></tr>
    	<tr><td colspan="2"><input type="submit" value="提交添加咯"></td></tr>
    </table>
    </form>
    </body>
    </html>
    

    2、删

    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    <script type="text/javascript">
    	function del(){
    		var userId=document.getElementById("userId").value;
    		var result=confirm("会不会删除啊?");
    		if(result==true){
    			window.location.href='delete1?id='+userId;
    		}
    		//alert(userId);		
    	}
    
    
    </script>
    </head>
    <body>
    <form action="delete" method="post">
    	请输入你要删除的id<input type="text" name="Id" id="userId">
    	<input type="button" value="删除" onclick="del();">
    	
    </form>
    </body>
    </html>
    

    3、改

    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="gbk">
    <title>Insert title here</title>
    </head>
    <body>
    <form action="upDate" method="post">
    <table>
    	<tr><td>用户编号</td><td><input type="text" name="id" value="@Id"></td></tr>
    	<tr><td>用户名</td><td><input type="text" name="userName" value="@userName"></td></tr>
    	<tr><td>用户邮箱</td><td><input type="text" name="Email" value="@Email"></td></tr>
    	<tr><td colspan="2"><input type="submit"  value="修改"></td></tr>
    </table>
    </form>
    
    </body>
    </html>
    

    4、登录

    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <form action="login" method="post">
    <table>
    	<tr><td>用户名</td><td><input type="text" name="userName" ></td></tr>
    	<tr><td>用户邮箱</td><td><input type="password" name="passWord" ></td></tr>
    	<tr><td colspan="2"><input type="submit"  value="登录"></td></tr>
    </table>
    </form>
    </body>
    </html>
    

    注意:
    编码格式需要统一,否则会出现乱码情况,查询修改等功能也可能报错

    展开全文
  • javaweb连接数据库并完成增删改查

    万次阅读 多人点赞 2018-12-09 16:31:00
    连接数据库 1、mysql数据库的安装和配置  在网上找到了篇关于mysql的安装详细说明,供读者自己学习  https://www.jb51.net/article/23876.htm 2、mysql的基本操作  找到了篇介绍MySQL的基本操作的文章,简单...
  • 利用javaweb、jsp、mysql语言进行编写,实现网上书城代码。可进行登录注册、购物车、订单查询。另外拥有后台管理界面,进行数据库后台操作。已经过课程设计答辩,可放心使用. 前台 1.1 首页 1.2 用户注册/登陆 1.3 ...
  • JavaWeb连接数据库MySQL

    千次阅读 2016-11-02 12:58:08
    简单演示一下JavaWeb数据库的操作。 1:我们需要掌握简单的SQL语句,并且会简单操作图形化的数据库。我们在数据库建一个表(Users)可以在里面随便添加几条数据。 2:接下来,我们获得驱动并连接到MySQ
  • 数据库的增删改查 <a href="insert.jsp"><span style="margin-left: 10px">添加数据</span></a> 查询用户信息 cellspacing="1" bgcolor="#CBD8AC" style="margin-pttom: 8px">+ <td>ID ...
  • javaweb开发之数据库

    千次阅读 2018-06-06 16:37:47
    以下为javaweb开发人员必须掌握的基础数据库知识总结。1、分别列举mysql和oracle数据库分页查询例子答:以用户信息表为例mysql分页:select s.* from sys_user s limit 0,5Oracle分页:select * from (select rownum...
  •  2.1 数据库工具类JdbcUtils.java  主要作用:获取Connection,以及关闭Connection 代码骨架如下: package com.njupt.javaweb.db; import java.sql.Connection; import java.sql.SQLException; im...
  • 2、查询所有学生信息: 3、点击1017学生后面的修改操作: 修改年龄为21: 修改后: 4、点击1019学生后面的删除操作: 点击确认后 5、点击添加学生: 输入要添加的学生信息 点击添加按钮后: Part02:主要...
  • 数据库中send_email表展示到页面上 分析 创建jsp页面 拿到list<Email>将数据显示在页面上 创建BeanEmail实体类 创建EmailServlet,BaseServlet类 响应编码设置 调用EmailService的findAll()方法,返回...
  • 一、JDBC执行数据库访问的步骤 1.导包 2.加载数据库驱动程序 3.连接数据库 4.创建sql指令对象 5.发送sql指令到数据库 6.处理结果 7.关闭数据库 二、下载MySQL驱动jar包 下载地址:...
  • 一张自增表里面总共有 7 条数据,删除了最后 2 条数据,重启 mysql 数据库,又插入了一条数据,此时 id 是几? 166.如何获取当前数据库版本? 167.说一下 ACID 是什么? 168.char 和 varchar 的区别是什么? 169....
  • JavaWeb实现简单对数据库的增删改查

    千次阅读 2021-03-13 11:41:49
    通过JavaWeb实现简单的对数据库的增删改查
  • 1 import java.sql.*;... 3 /*默写数据库练习数据库编程及注释讲解代码*/ 4 public class Main{ 5 public static void main(String[]args)throws Exception{ 6 7 Class.forName("com.mysql.cj.jdbc...
  • 本项目是一套基于JavaWeb的企业员工信息管理系统,主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。 包含:项目源码、数据库脚本、软件工具、项目说明等,该项目可以直接作为毕设使用。 ...
  • JavaWeb学生信息管理系统_删除V2.0

    千次阅读 2018-08-05 13:55:49
    1)在上个项目查询完成的基础上,添加一个删除的功能,点击删除,可以把数据库里的学生信息删除,并刷新显示学生信息的页面 2)在Web页面添加一个删除的超链接,发送请求到delStuServlet 3)根据发送的get请求,...
  • 在计算机上–按照数据库软件 关系型数据库 SQLServer,Oracle,db2,Mysql(开源,小型化) 非关型数据库 典型代表:mangodb/redis(key-value形式)---(缓存一些数据) 验证是否安装完毕(登录成功,说明mysql的环境变量...
  • javaweb数据库操作

    2019-05-21 10:14:29
    1.首先在电脑中找到服务,启动MYSQL(mysql需要自己先安装好),我自己安装好的mysql, ... 3.数据库的一些指令 ...创建数据库:create database 数据库名称;...删除数据库:drop database 数据库名称; 4.SQL命...
  • javaweb校园宿舍管理系统(源文件+数据库)直接导入就能用。 各部分完成的功能如下:1、用户管理部分1、处理用户注册2、处理用户登录 3、用户可以查询学生信息。 4、用户可以提交与查询报修信息。 5、用户可以...
  • JavaWeb数据库操作 JDBC[Java数据库连接:Java Data Base Connectivity]连接数据局的过程: 1、注册数据库驱动: 连接数据库前,需要将数据库厂商提供的数据库驱动类注册到JDBC的驱动管理中...
  • jsp药品信息管理系统 是一套完善的WEB设计系统,对理解JSP java 编程开发语言有帮助,系统具有完整的源代码和数据库,系统主要采用B/S模式开发。 应用技术:java|jsp+mysql 开发工具:Myeclipse或Eclipse、jdk、...
  • 删除 修改 查询 在src目录下新建一个包com.njupt.javaweb.servlet,并在其下创建CustomerServlet.java,映射为/customerServlet package com.njupt.javaweb.servlet; import java.io.IOException; ...
  • Javaweb数据库、SQL】

    2020-04-08 21:10:12
    数据库的基本概念 MySQL数据库软件 安装 卸载 配置 SQL 数据库的基本概念 1. 数据库的英文单词: DataBase 简称 : DB 2. 什么数据库? * 用于存储和管理数据的仓库。 3. 数据库的特点: 1. 持久化存储...
  • 1.1.1 什么是数据库数据库:就是一个文件系统,这个文件必须通过标准的SQL访问. 1.1.2什么是关系型数据库: 关系型的数据库存放的都是实体之间的关系.   1.1.3 常用的关系型数据库: MySQL:免费的小型的...
  • IDEA创建第一个Javaweb项目包括数据库连接

    千次阅读 多人点赞 2020-03-31 10:15:17
    本文旨在让刚入门Java的新手能够创建第一个web项目,能够对Javaweb开发有一个基本的认识和了解。 本文所用工具:Intellij IDEA,可在官网下载社区版或专业版,社区版是免费的。 环境:jdk 12.0.2 web服务器软件:...
  • 数据库连接没有问题,可以新增和修改数据,就是删除操作不可以,点了没反应,但是也没有报错,Tomcat没有错误日志,是从eclipse上运行项目的时候显示400,解析http请求header错误,搞了好几天了找不到哪里出问题,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,160
精华内容 5,664
关键字:

javaweb删除数据库信息

java 订阅