JDBC使用 & Java Web数据可视化案例
文章目录
- 数据可视化
- 使用JDBC访问数据库中数据
-
- JDBC
- JDBC使用
-
- JDBC实例添加
- JDBC实例删除
- JDBC实例修改
- JDBC实例查询
- 工具类DBBean介绍
- 读取数据库数据提供给浏览器
-
- 编写实体Bean
- 编写Dao类
- 编写Service类
- 编写Servlet类
- 编写HTML文件
- Java Web数据可视化案例
-
- 第一部分：实体Bean
- 第二部分：DAO代码
- 第三部分：Servlet代码
- 第四部分：JSP页面
- 第五部分：SQL语句
- 实现自己数据的展示
数据可视化
推荐网站：https://echarts.apache.org/zh/index.html
点击【示例】
随便选择一个图形
左边放入代码后，左上角运行
主要内容
使用JDBC访问数据库中数据
首先需要创建数据库和表使用MySQL创建数据库和表，也可以看下面的语句
用命令行方式创建：新冠病毒数据库
创建数据库：create database practice2020;
使用数据库：use practice2020
创建表：
create table ncov2020(
id int primary key auto_increment,
quantity int,
editdate datatime
);
为了方便在界面上展示效果在这插入语句：
insert into ncov2020 values(null,77,'2020-1-20');
JDBC
①、 JDBC是Java访问各种数据库管理系统的标准的API，用户编写数据库访问代码的时候不需要关注数据库管理系统的实现细节。
②、使用JDBC的准备工作：
不同的数据库管理系统需要对应的驱动程序，驱动程序是一个压缩包jar包。
要访问的数据库的基本信息：数据库位置（IP+端口+数据库名），认证信息（用户名和口令)
SQL语句：要完成的功能对应的SQL语句
③、 JDBC相关的接口和类：
Driver：表示连接数据库的驱动程序，通过驱动程序与数据库交互；
Connection：表示应用程序与数据库之间的连接，不管进行什么操作都要先连接到数据库；
Statement、PreparedStatement、CallableStatement：执行SQL语句
ResultSet：表示执行查询时候的结果集
JDBC使用
①、加载驱动程序：
格式：Class.forName(驱动程序名字)
例如：Class.forName("com.mysql.jdbc.Driver");
②、创建连接：
格式：Connection con = DriverManager.getConnection(constr,user,pass);
constr表示连接字符串，user表示用户名，pass表示密码
例如：Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/bookstore" ,"root" ,"root");
③、创建语句对象：
格式：Statement stmt = con.createStatement();
④、执行增删改：
格式：int n = stmt.executeUpdate(sql)， n表示执行成功的记录数
例如：
String sql = "insert into student values('000004,wangfei',20)";
int n = stmt.executeUpdate(sql);
正常插入返回1，插入失败返回0
⑤、执行查询：
格式：ResultSet rs = stmt.executeQuery(sql)，n表示执行成功的记录数，sql表示要执行的sql语句
例如：
String sql ="select * from student";
ResultSet rs = stmt.executeQuery(sql);
⑥、结果集处理：
结果集就像一个有表头的表格
通过next方法指向下一行，如果没有下一行返回false
使用getInt(n)，或者getInt(列名)得到当前行的第一列，返回值是int类型
使用getString(n)，或getString(列名)，返回值是String类型
查询单个值（例如某个表的记录数）：
rs.next();
int n = rs.getInt(1);
查询一条记录(例如根据主键查询学生）：
if(rs.next())
String sname = rs.getString(2)
查询多条记录（例如查询所有学生)：
while(rs.next))
String sname = rs.getString(2);
⑦、关闭相关对象：
需要关闭的对象：连接对象Connection、语句对象Statement、结果集对象ResultSet
关闭顺序：结果集对象、语句对象、连接对象
通常关闭的时候，需要异常处理：
//加载驱动程序，驱动程序不存在
//执行的SQL语句出错了
//连接的数据库不存在，数据库没有启动也会出错
if(rs!=null) try{rs.close()}catch(Exception e);
if(stmt!=null) try{stmt.close()}catch(Exception e);
if(con!=null) try{con.close()}catch(Exception e);
⑧、异常处理
在访问数据库的过程中可能发生各种异常，所以需要进行异常处理。
JDBC实例添加
Connection con = null;
PreparedStatement pstmt = null;
try{
Class.forName("com.mysql.jdbc.Driver"); //加载驱动程序
//连接数据库，其中127.0.0.1是虚拟的本机地址，jsp是要访问的数据库名字
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jsp","root", "root");
//创建了执行sql语句的对象，他把SQL语句作为参数直接传进来（预编译的语句对象）
pstmt = con.prepareStatement("insert into student values('000004','wangfei ,20)");
//executeUpdate()这里面没有参数，因为在创建预编译对象的时候，已经把SQL语句作为参数传进去了
int n = pstmt.executeUpdate();//返回值表示影响数据库记录的个数，增删改都使用该方法
//n表示插入成功还是失败
if(n>0){
System.out.println("添加学生成功!");
}else{
System.out.println("添加学生失败!");
}
}catch(Exception e){
e.printStackTrace();
} finally{
//关闭语句对象，关闭连接对象
if(pstmt!=null) {
try {
pstmt.close();
} catch (Exception e2) {
}
}
if(con!=null) {
try {
con.close();
} catch (Exception e2) {
}
}
}
// 把表示所有对象的数据返回
return datas;
}
JDBC实例删除
Connection con = null;
PreparedStatement pstmt = null;
try{
Class.forName("com.mysql.jdbc.Driver");//加载驱动程序
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jsp"
"root", "root"); // 连接数据库,
//创建了执行sql语句的对象
pstmt = con.prepareStatement("delete from student where sid='00001'");
//对SQL中的变量赋值
int n = pstmt.executeUpdate();//返回值表示影响数据库记录的个数，增删改都使用该方法
if(n>0){
System.out.println("删除学生成功!");
}else{
System.out.println("删除学生失败!");
}
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭语句对象，关闭连接对象
if(pstmt!=null) {
try {
pstmt.close();
} catch (Exception e2) {
}
}
if(con!=null) {
try {
con.close();
} catch (Exception e2) {
}
}
}
// 把表示所有对象的数据返回
return datas;
}
JDBC实例修改
Connection con = null;
PreparedStatement pstmt = null;
try{
Class.forName("com.mysql.jdbc.Driver"); //加载驱动程序
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jsp",
"root","root"); //连接数据库
//创建了执行sql 语句的对象
pstmt = con.prepareStatement("update student set sname=? where sid=?");
//对SQL中的变量赋值
pstmt.setString(1, sname);
pstmt.setString(2, sid);
int n = pstmt.executeUpdate();//返回值表示影响数据库记录的个数，增删改都使用该方法
if(n>0){
System.out.println("修改学生成功!");
}else{
System.out.println("修改学生失败!");
}
}catch(Exception e){
e.printStackTrace();
}finally {
//关闭语句对象，关闭连接对象
if(pstmt!=null) {
try {
pstmt.close();
} catch (Exception e2) {
}
}
if(con!=null) {
try {
con.close();
} catch (Exception e2) {
}
}
}
// 把表示所有对象的数据返回
return datas;
}
JDBC实例查询
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
Class.forName("com.mysq1.jdbc.Driver");//加载驱动程序
con=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jsp",
"root", "root"); //连接数据库
//创建了执行sql语句的对象
pstmt = con.prepareStatement("select * from student");
rs = pstmt.executeQuery();//得到结果集
//对多条结果集处理的格式，有记录就循环
while(rs.next()){
String sid = rs.getString(1);
String sname = rs.getString(2);
String sage = rs.getString(3);
System.out.println(sid+"--"+sname+"--"+sage);
}
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭结果集对象，关闭语句对象，关闭连接对象
if(rs!=null) {
try {
rs.close();
} catch (Exception e2) {
}
}
if(pstmt!=null) {
try {
pstmt.close();
} catch (Exception e2) {
}
}
if(con!=null) {
try {
con.close();
} catch (Exception e2) {
}
}
}
// 把表示所有对象的数据返回
return datas;
}
}
工具类DBBean介绍
package util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
public class DBBean {
//数据库信息，旧版本中不用useSSL=false
private String url = "jdbc:mysql://localhost:3306/practice2020?useSSL=false";
private String username = "root";
private String password = "root";
private String driverName = "com.mysql.jdbc.Driver";
private Connection con=null; //连接对象
private PreparedStatement pstmt = null; //语句对象
private ResultSet rs = null; //结果集对象
//连接、执行、关闭
public DBBean() throws ClassNotFoundException, SQLException {
//加载驱动程序，创建连接
Class.forName(driverName);
con = DriverManager.getConnection(url,username,password);
}
//增删改（区别在SQL语句和SQL语句里面需要的变量）
public int executeUpdate(String sql,List<Object> params) throws SQLException{
//创建语句对象
pstmt = con.prepareStatement(sql);
//如果有参数，表示提供的参数在SQL语句里面需要变量。如果变量和参数不一致，报错
if(params!=null && params.size()>0){
//有多少变量循环多少次
for(int i=0;i<params.size();i++){
//对变量赋值
pstmt.setObject(i+1,params.get(i));
}
}
return pstmt.executeUpdate();
}
//查询
public ResultSet executeQuery(String sql,List<Object> params) throws SQLException{
pstmt = con.prepareStatement(sql);
if(params!=null && params.size()>0){
for(int i=0;i<params.size();i++){
pstmt.setObject(i+1,params.get(i));
}
}
return pstmt.executeQuery();
}
//关闭
public void close(){
if(rs!=null){
try {rs.close();
}catch(Exception ee){}
}
if(pstmt!=null){
try {pstmt.close();
}catch(Exception ee){}
}
if(con!=null){
try {con.close();
}catch(Exception ee){}
}
}
}
读取数据库数据提供给浏览器
编写实体Bean
通常与数据库中的表结构一致。
package bean;
import java.util.Date;
public class NcovData {
private int id;
private int quantity;
private Date editDate;
public NcovData()
public NcovData(int id,int quantity,Date editDate){
this.id = id;
this.quantity = quantity;
this.editDate = editDate;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
编写Dao类
访问数据库，取出数据库数据
NcovDao
public List<NcovData> list(){
// (1)定义存储数据的容器
List<NcovData> datas= new ArrayList<NcovData>();
// （6）写sql语句
String sql = "select * from ncov2020";
// (2)创建DBBean对象
DBBean bean = null;
// (3)try...catch...finally
try {
// (7)创建DBBean对象，实际上就是连接到数据库
bean = new DBBean();
// （8）执行sql语句，会得到结果集
ResultSet rs = bean.executeQuery(sql, null);
// （9）遍历结果集，next指向下一行，并返回true，
// 如果没有下一行了，返回false，循环结束
while(rs.next(){
// (10)取出当前行的各个列
int id = rs.getInt(1);
int quantity = rs.getInt(2);
Date editdate = rs.getDate(3);
// (11)转换成对象(封装成），调用多个参数的构造方法
NcovData data = new NcovData(id,quantity,editdate);
// (12)把当前对象添加到集合中（容器中）
datas.add(data);
}
}catch(Exception e){
// （4）处理异常
e.printStackTrace();
}finally {
// (5)释放资源
bean.close();
}
// （13）把表示所有对象的数据返回
return datas;
}
编写Service类
进行业务处理，如果没有业务，只是把Dao里面的数据直接返回给Controller
NcovService
package service;
import java.util.List;
import bean.NcovData;
import dao.NcovDao;
public class NcovService {
NcovDao dao = new NcovDao();
public List<NcovData> list(){
return dao.list();
}
}
编写Servlet类
NcovServlet
@WebServlet("/NcovServlet")
public class NcovServlet extends HttpServlet {
private static final long serialVersionUID= 1L;
protected void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=utf-8");
PrintWriter out = response.getWriter();
NcovService service = new NcovService();
List<NcovData> datas = service.list();
String info = JSON.toJSONString(datas);
out.print(info);
}
protected void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}
编写HTML文件
ncov.html
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>新冠病毒数据title>
<script src="js/jquery-3.4.1.min.js">script>
<script>
function refreshTable(result){
var $tab=$("#ncovTable");
$tab.empty();
for (var i=O;i<result.length;i++){
//从json数组得到json对象
var data = result[i];
var info = "" + data.id + " "+data.quantity+" "+data.editDate + " Java Web数据可视化案例
第一部分：实体Bean
package bean;
// (1)类名
// (2)成员变量，和表中的列对应
// (3)访问器方法，setter方法和getter方法
// (4)无参数构造方法
// (5)有参数的构造方法，有多少个成员，就给多少个参数
public class StudentQuantity {
private int id;
int year;
int quantity;
// 如果要提供有参数的构造方法，通常需要把无参数的构造方法写出来，方法体可以为空
public StudentQuantity(){
}
/*
* 分别为3个成员变量赋值
*/
public StudentQuantity(int id,int year,int quantity) {
this.id = id;
this.year = year;
this.quantity = quantity;
}
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
}
第二部分：DAO代码
// 得到所有数据
public List<StudentQuantity> list(){
// (1)定义存储数据的容器
List<StudentQuantity> datas = new ArrayList<>();
// （2）把相关对象定义成成员变量
// (3)try...catch...finally
try {
// （6）写sql语句
String sqlString = "select * from studentquantity order by year";
// (7)连接到数据库
Class.forName(driverName);
con = DriverManager.getConnection(url,username,password);
// （8）执行sql语句，会得到结果集
pstmt = con.prepareStatement(sqlString);
ResultSet rSet = pstmt.executeQuery(sqlString);
// （9）遍历结果集，next指向下一行，并返回true，
// 如果没有下一行了，返回false，循环结束
while(rSet.next()) {
// (10)取出当前行的各个列
int id = rSet.getInt(1);
int year = rSet.getInt(2);
int quantity = rSet.getInt(3);
// (11)转换成对象(封装成），调用多个参数的构造方法
StudentQuantity studentQuantity = new StudentQuantity(id, year, quantity);
// (12)把当前对象添加到集合中（容器中）
datas.add(studentQuantity);
}
} catch (Exception e) {
// （4）处理异常
//System.out.println(e.getMessage());
e.printStackTrace();
} finally {
// (5)释放资源
if(rs!=null) {
try {
rs.close();
} catch (Exception e2) {
}
}
if(pstmt!=null) {
try {
pstmt.close();
} catch (Exception e2) {
}
}
if(con!=null) {
try {
con.close();
} catch (Exception e2) {
}
}
}
// （13）把表示所有对象的数据返回
return datas;
}
第三部分：Servlet代码
package servlet;
import java.io.IOException;
import java.util.List;
import javax.servlet.RequestDispatcher;
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 bean.StudentQuantity;
import service.StudentQuantityService;
// （1）关联到FindAll地址
@WebServlet("/FindAll")
public class FindAllServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// （2）前两行调用servcie或者DAO得到数据
//StudentQuantityService service = new StudentQuantityService();
//List datas = service.list();
StudentQuantityDao dao = new StudentQuantityDao();
List<StudentQuantity> datas = dao.list();
// （3）传值到界面，第一个参数是名字，第二个参数是具体值
request.setAttribute("datas", datas);
// （4）跳转到界面，list.jsp是显示数据的界面，list.jsp可以继续访问request
RequestDispatcher rd = request.getRequestDispatcher("list.jsp");
rd.forward(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}
第四部分：JSP页面
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>数据列表</title>
</head>
<body>
<table>
<tr>
<th>编号</th>
<th>年度</th>
<th>人数</th>
</tr>
<!-- request.setAttribute("datas",datas); -->
<!-- datas表示所有数据，data表示其中的一个数据 -->
<c:forEach var="data" items="${datas}">
<tr>
<td>${data.id}</td>
<td>${data.year}</td>
<td>${data.quantity}</td>
</tr>
</c:forEach>
</table>
</body>
</html>
第五部分：SQL语句
create table ncov2020(
id int primary key auto_increment,
quantity int,
editdate datetime
);
insert into ncov2020 values(null,77,'2020-1-20');
insert into ncov2020 values(null,149,'2020-1-21');
insert into ncov2020 values(null,131,'2020-1-22');
insert into ncov2020 values(null,259,'2020-1-23');
实现自己数据的展示
基本过程：
（1）创建 Web 工程；
（2）创建表示信息的实体类；
（3）添加两个类库：json 和 mysql 驱动程序；
（4）复制 DBBean，修改数据库信息；
（5）创建 DAO，从数据库中获取信息；
（6）创建 Service，调用 DAO 得到数据；
（7）创建 Servlet，调用 Service，对用户返回 JSON 数据；
（8）创建页面文件，获取 Servlet 的数据并显示。