回顾：
封装：临时存放我们的查询出来的记录
集合：存放所有的记录对象，取出所有的查询出来的记录
封装用来生产实体类。
集合用来存放实体类。
单元测试，导致依赖junit4
JDBC增加、删除、修改
1.JDBC查询
查询 增加、删除、修改
加载驱动 加载驱动 Class.forName() Class.forName()
创建连接 创建连接 Connection Connection
创建SQL执行对象 创建SQL执行对象 Statement Statement
执行SQL ，有结果集 执行SQL没有结果集 ResultSet 无
通过实体类存入集合 释放资源 List 实体类 close()
释放资源 close()
2、抽取工具类
加载驱动 、创建连接;
释放资源；
（1）创建配置文件
resources ----> jdbc.properties
driver= com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/ooo
username = root
password = 123456
（2）编写工具类
static {
//1-2-1将配置文件，转换成输入流
InputStream resourceAsStream = jdbc_Utils.class.getClassLoader().getResourceAsStream("jdbc.properties");
//1-2-2 、通过属性对象（Properties），关联输入流
Properties properties = new Properties();
try {
properties.load(resourceAsStream);
driver = properties.getProperty("driver");
url = properties.getProperty("url");
username = properties.getProperty("username");
password = properties.getProperty("password");
Class.forName(driver);
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}finally {
try {
resourceAsStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
（2-1）编写获取连接方法 ,读取配置文件加载驱动
public static Connection getConnection(){
Connection connection = null;
try {
DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
throw new RuntimeException(e);
}
return connection;
}
（2-2） 编写释放资源方法
public static void closeAll(ResultSet resultSet, Statement statement,Connection connection) throws SQLException {
if (resultSet != null){
resultSet.close();
}
if (statement!= null){
statement.close();
}
if (connection != null){
connection.close();
}
}
3.工具类的使用
工具类为我们解救了2个问题 ：（1）获取连接 （2）释放资源
@Test
// public void jdbcutilselect() throws SQLException {
// String select_sql = "select * from user";
// Connection connection = jdbc_Utils.getConnection();
// Statement statement = connection.createStatement();
// ResultSet resultSet = statement.executeQuery(select_sql);
// List<user> users = new ArrayList<>();
//
// while (resultSet.next()) {
// user user = new user();
// user.setId(resultSet.getInt("id"));
// user.setUsername(resultSet.getString("username"));
// user.setPassword(resultSet.getString("password"));
// user.setNickname(resultSet.getString("nickname"));
// users.add(user);
// }
// for (user i : users) {
// System.out.println(i.toString());
// }
//
// jdbc_Utils.closeAll(resultSet,statement,connection);
//
// }
// @Test
// public void jdbcutilselect01() throws SQLException {
// String select_sql = "select * from user where id = 1";
// Connection connection = jdbc_Utils.getConnection();
// Statement statement = connection.createStatement();
// ResultSet resultSet = statement.executeQuery(select_sql);
// List<user> users = new ArrayList<>();
//
// while (resultSet.next()) {
// user user = new user();
// user.setId(resultSet.getInt("id"));
// user.setUsername(resultSet.getString("username"));
// user.setPassword(resultSet.getString("password"));
// user.setNickname(resultSet.getString("nickname"));
// users.add(user);
// }
// for (user i : users) {
// System.out.println(i.toString());
// }
//
// jdbc_Utils.closeAll(resultSet, statement, connection);
//
// }
@Test
public void jdbcdelete() throws SQLException {
String delete_sql = "delete from user where id = 3";
Connection connection = jdbc_Utils.getConnection();
Statement statement = connection.createStatement();
statement.executeUpdate(delete_sql);
jdbc_Utils.closeAll(null, statement, connection);
}
回顾：
函数：数学函数、字符串函数、日期时间函数、系统信息函数、其他函数
1、数据库设计
1.1、范式
规则：优化数据的设计和存储。
1.2、分类
第一范式、第二范式、第三范式、BCNF、第四范式、第五范式
1.3、
第一范式
确保每个字段不可再分，确保每列原子性。
第二范式
一个表只能描述一件事情。
第三范式
消除传递依赖，所有的非键字段中，不能有传递依赖。
反三范式：性能比范式重要。
2、数据库还原和备份
2.1、什么是数据库备份
导出数据或复制表文件来制作数据库的副本。
2.2、备份
格式：
mysqldump -u用户名 -p密码 数据库名 > sql文件位置
格式：
mysqldump -u用户名 -p密码 数据库名 数据库表名1 数据库表名2> sql文件位置
格式：
mysqldump -u用户名 -p密码 --databases 数据库名1 数据库名2> sql文件位置
格式：
mysqldump -u用户名 -p密码 --all-databases > sql文件位置
2.3、还原
格式：
source 导入文件的路径;
3、DCL
1.1、什么DCL
管理系统中对象权限，一般是DBA在用
创建用户、给用户授权、对用户撤销授权、查询用户授权、删除用户。。。。。
1.2、用户管理
查看用户
格式：
select * from user;
注意：表都在mysql数据库下
创建用户
格式：
create user '用户名'@'主机名' identified by '密码';
删除用户
格式：
drop user '用户名'@'主机名';
密码管理
格式：
alter user '用户名'@'主机名' identified by '密码';
alter user 'root1'@'localhost' identified by '456';
alter user 'root1'@'localhost' identified with mysql_native_password by '567';
清空密码：
update user set authentication_string='' where user='root';
在设置：
alter user 'root'@'%' identified by 'Root12345';
alter user 'root'@'localhost' identified by 'Root12345';
回顾：
mysql数据库 ******
DBA
1、JDBC
java database connection 规范，API，接口。
jdbc与数据库驱动的关系，就是接口与实现的关系。
2、快速入门JDBC
2.1、准备好数据库与数据库表
create table user(
id int primary key auto_increment,
username varchar(20),
password varchar(20),
nickname varchar(20)
);
INSERT INTO `USER` VALUES(null,'zs','123456','老张');
INSERT INTO `USER` VALUES(null,'ls','123456','老李');
INSERT INTO `USER` VALUES(null,'wangwu','123','东方不败');
2.2、创建一个JAVA工程
maven 创建我们的java项目，包（jar包）统一管理。
pom.xml
修改pom.xml里面的配置文件，必须重新更新（reload project）。
jdbc_demo_01
2.3、准备好驱动jar包
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
2.4、编写代码
（1）加载驱动
DriverManager.registerDriver(new Driver());
（2）创建数据库连接
url格式：jdbc:mysql://ip:port/dbname
String url="jdbc:mysql://localhost:3306/db02";
String username="root";
String password="Root123456";
Connection connection=DriverManager.getConnection(url,username,password);
（3）操作数据库表
需求：查询user表中所有的记录
A、准备好查询的SQL
String sql="select * from user";
B、创建执行SQL的对象
Statement statement=connection.createStatement();
C、执行SQL，得到结果集
ResultSet resultSet=statement.executeQuery(sql);
D、展示查询出来的结果
while(resultSet.next()){
System.out.print(resultSet.getObject(1)+" ");
System.out.print(resultSet.getObject(2)+" ");
System.out.print(resultSet.getObject(3)+" ");
System.out.print(resultSet.getObject(4)+" ");
System.out.println();
}
（4）释放资源
resultSet.close();
statement.close();
connection.close();
第一个案例：
package com.ww.jdbc.test;
import com.mysql.cj.jdbc.Driver;
import java.sql.*;
public class JdbcTest {
public static void main(String[] args) throws SQLException {
//1、加载驱动
DriverManager.registerDriver(new Driver());
//2、连接数据库
//声明url,username,password
String url="jdbc:mysql://localhost:3306/db02";
String username="root";
String password="Root123456";
Connection connection=DriverManager.getConnection(url,username,password);
//3、操作数据库表
String sql="select * from user";
Statement statement=connection.createStatement();
ResultSet resultSet=statement.executeQuery(sql);
//循环打印出所有记录（结果集）
while(resultSet.next()){
System.out.print(resultSet.getObject(1)+" ");
System.out.print(resultSet.getObject(2)+" ");
System.out.print(resultSet.getObject(3)+" ");
System.out.print(resultSet.getObject(4)+" ");
System.out.println();
}
//4、释放资源（先创建，后关闭）
resultSet.close();
statement.close();
connection.close();
}
}
回顾：
jdbc 接口 驱动类实现
maven 创建项目 pom.xml导入依赖
第一个JDBC案例：
（1）创建maven的java项目
（2）pom.xml导入mysql数据库驱动jar包
（3）代码编写：
1、加载驱动
2、创建连接
3、创建操作SQL类
4、执行SQL，处理结果集
5、释放资源
java.sql.*
DriverManager.registerDriver()
DriverManager.getConnection()
Connection
Statement
ResultSet
1、JDBC API详解
1.1、DriverManager
加载驱动
DriverManager.registerDriver(new Driver())
mysql8.jar com.mysql.cj.jdbc.Driver
mysql5.jar com.mysql.jdbc.Driver
Class.forName("com.mysql.cj.jdbc.Driver"); //反射机制
创建连接
DriverManager.getConnection(url,username,password)
url地址连接mysql格式：
jdbc:mysql://ip地址：端口号/数据库名
jdbc:mysql://localhost:3306/db02
jdbc:mysql://…/db02
1.2、Connection
是数据库连接对象。
Statement<=createStatement() 创建执行SQL语句对象
拿到SQL语句就只能直接执行。
例：
Connection conn=DriverManager.getConnection(url,username,password);
Statement state=conn.createStatement();
PreparedStatement<=prepareStatement() 创建预编译执行SQL语句对象
拿到SQL语句可以先编译，在执行。
例：
Connection conn=DriverManager.getConnection(url,username,password);
PreparedStatement state=conn.prepareStatement();
1.3、Statement
直接执行写好的SQL语句。
executeQuery(sql) 只能执行DQL语句，select查询语句
例：
String sql=“select * from user”;
Connection conn=DriverManager.getConnection(url,username,password);
Statement state=conn.createStatement();
ResultSet rs=state.executeQuery(sql);
executeUpdate(sql) 只能执行DML语句，insert update delete语句
例：
String sql=“delete from user where id=1”;
Connection conn=DriverManager.getConnection(url,username,password);
Statement state=conn.createStatement();
state.executeUpdate(sql);
execute() 执行任意语句，返回true/false
例1：
String sql=“select * from user”;
Connection conn=DriverManager.getConnection(url,username,password);
Statement state=conn.createStatement();
Boolean isval=state.execute(sql);
注意：
isval为true，表示查询到了用户记录
isval为false，表示没有查询到用户记录
例2：
String sql=“delete from user where id=1”;
Connection conn=DriverManager.getConnection(url,username,password);
Statement state=conn.createStatement();
Boolean isval=state.execute(sql);
注意：
isval为false，增加语句、修改语句、删除语句没有结果集
1.4、ResultSet
对象，结果集
next() 方法：游标往下移一行，判断是否存在记录，存在就用get方法来取值
get方法：
getInt(int i) i表示的是位置 getInt(String name) name表示的是字段名
getString（）
getDouble()
getBoolean()
getDate()
……
例：
String sql=“select * from user”;
Connection conn=DriverManager.getConnection(url,username,password);
Statement state=conn.createStatement();
ResultSet rs=state.executeQuery(sql);
while(rs.next()){
System.out.println(rs.getInt(1));
System.out.println(rs.getInt(“id”));
}
案例：
package com.ww.jdbc.test;
import java.sql.*;
public class JdbcTest {
public static void main(String[] args) throws SQLException, ClassNotFoundException {
//1、加载驱动
// DriverManager.registerDriver(new Driver());
Class.forName("com.mysql.cj.jdbc.Driver"); //反射机制
//2、连接数据库
//声明url,username,password
String url="jdbc:mysql://localhost:3306/db02";
String username="root";
String password="Root123456";
Connection connection=DriverManager.getConnection(url,username,password);
//3、操作数据库表
String sql="select * from user";
Statement statement=connection.createStatement();
ResultSet resultSet=statement.executeQuery(sql);
//循环打印出所有记录（结果集）
while(resultSet.next()){
System.out.print(resultSet.getObject("id")+" ");
System.out.print(resultSet.getObject("username")+" ");
System.out.print(resultSet.getObject("nickname")+" ");
System.out.print(resultSet.getObject("password")+" ");
System.out.println();
}
//4、释放资源（先创建，后关闭）
resultSet.close();
statement.close();
connection.close();
}
}
回顾:
DriverManager : //加载驱动，创建连接 耦合度太高 jar包驱动
Class.forName() //记载驱动 推荐
Connection:创建SQL执行对象，创建SQL预编译执行对象
Statement：执行查询语句；执行增加、删除、修改语句；任何SQL
ResultSet：结果集处理。需要使用next()下一条记录 getObject(1) getlnt("id") getString() getDate();
1、封装
javabean/实体类
Persion{
属性
方法
}
让属性不可以直接获取，得到方法（get/set）得到
封装的时候针对的是表，所以我们的实体类的所有的属性都要和表中的字段对应
回忆（*****）:
集合：存储各种数据类型。
List常用，存放对象add();集合的对象读
结果集存储
List<user> list = new ArrayList<user>();
while (resultSet.next()){
// System.out.println(resultSet.getObject("id"));
// System.out.println(resultSet.getObject("username"));
// System.out.println(resultSet.getObject("password"));
// System.out.println(resultSet.getObject("nickname"));
user user = new user();
user.setId(resultSet.getInt("id"));
user.setUsername(resultSet.getString("username"));
user.setPassword(resultSet.getString("password"));
user.setNickname(resultSet.getString("nickname"));
list.add(user);
}
结果集读取
//循环打印
for (user u:list){
System.out.println(u.toString());
}
//迭代方式打印
Iterator<user> iterator = list.iterator();
while (iterator.hasNext()){
user next = iterator.next();
System.out.println(next);
}
代码 user_ bean；
package com.ww.jdbc_demo_01.javabean;
public class user {
//将所有的属性私有化
private int id ;
private String username;
private String password;
private String nickname;
//为了产生实体类对象，构造方法必须有无参和全参
public user() {
}
public user(int id, String username, String password, String nickname) {
this.id = id;
this.username = username;
this.password = password;
this.nickname = nickname;
}
//想要存储属性的值，通过get/set方法
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 getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
//@Override注解
@Override
public String toString() {
return "user{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
1. 操作数据库（CRUD）增删改查
1.1 、单元测试 （属于第三方工具 所以得导入jar包）
JUnit 导入依赖
在测试添加@Test注解
导入依赖
<dependency>-->
<!-- <groupId>junit</groupId>-->
<!-- <artifactId>junit</artifactId>-->
<!-- <version>4.13.1</version>-->
<!-- <scope>test</scope>-->
<!-- </dependency>-->
代码展示：
//可执行标记相当于main
// 一个类可以有多个执行接口
// @Test
{
System.out.println("单元测试");
}
// @Test
public void select(){
}
1.2要想完成增删改查 CRUD
步骤：
加载驱动
获取连接
创建SQL执行对象（CRUD+）
执行SQL
释放资源
//增加，修改，删除
//增加测试
// @Test
public void insertuser() throws ClassNotFoundException, SQLException {
//加载驱动
String insert_sql = "insert into user values(null,'zhangge','z123546','张三')";
String url ="jdbc:mysql://localhost:3306/ooo";
String username = "root";
String password = "123456";
//创建连接
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, username, password);
Statement statement = connection.createStatement();
statement.executeUpdate(insert_sql);
statement.close();
connection.close();
}
public void updateuser() throws ClassNotFoundException, SQLException {
String update_sql= "update user set nickname = '李素' where id = 4 ";
String url ="jdbc:mysql://localhost:3306/ooo";
String username = "root";
String password = "123456";
//创建连接
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, username, password);
Statement statement = connection.createStatement();
statement.executeUpdate(update_sql);
statement.close();
connection.close();
}
public void deleteuser() throws ClassNotFoundException, SQLException {
String delete_sql = "delete form user where id = 4 ";
String url = "jdbc:mysql://localhost:3306/ooo";
String username = "root";
String password = "123456";
//创建连接
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, username, password);
Statement statement = connection.createStatement();
statement.executeUpdate(delete_sql);
statement.close();
connection.close();
}
回顾：
抽取JDBCUtils.java（IO流、Properties、jdbc.properties）
封装了加载驱动、获取连接、释放资源
编写实体类：针对数据库表中的字段来创建属性。
set/get
重写构造函数（无参、全参）
重写toString()方法
实体类使用位置：
查询后有结果集。
结果集一条一条的存入到实体类，实体类一条一条的存入集合。
集合：返回、打印输出
打印输出集合用过二种方式：迭代器、增加For、流
1、PreparedStatement
预编译执行SQL对象
? 替换符
案例：
@Test
public void demo01() throws SQLException {
int id=3;
String sql="select * from user where id=?";
//1、获取连接
Connection connection=JdbcUtils.getConnection();
//2、获取预编译执行SQL对象
PreparedStatement ps=connection.prepareStatement(sql);
ps.setInt(1,id);
//3、执行SQL
ResultSet rs=ps.executeQuery();
//4、结果集存入到实体类，实体类存入到集合
List<User> list=new ArrayList<User>();
while(rs.next()){
User user=new User();
user.setId(rs.getInt("id"));
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
user.setNickname(rs.getString("nickname"));
list.add(user);
}
//展示集合中存放的结果集。
for(User u:list){
System.out.println(u.toString());
}
}
登录案例：
（1）分析
用一个登录页面；
去查询数据库判断有没有输入的用户和密码；
有就输出登录成功，没有就输出登录失败
（2）前期准备
输出流、输入流
数据库、数据库表、Jdbc工具类、JdbcAPI
（3）代码步骤
（3-1）idea新建maven项目
（3-2）导入依赖，mysql，junit
（3-3）创建实体类User
（3-4）创建配置文件jdbc.properties
（3-5）创建工具类JdbcUtils.java
（3-6）创建一个登录类
（3-6-1）创建输出页面的方法
（3-6-2）输入用户密码和密码
（3-6-3）去数据库查询用户名和密码是否存在
（3-6-4）存在，就输出登录成功！，不存在就输出登录失败
package com.ww.jdbc.junit;
import com.ww.jdbc_demo_01.util.JdbcUtils;
import org.junit.Test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;
public class JdbcLogin {
public static void main(String args[]) throws SQLException {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入用户名：");
String username=scanner.next();
System.out.println("请输入密码：");
String password=scanner.next();
//去数据库里面查看用户名是否存在
String sql ="select * from user where username=? and password=?";
//去数据库查询用户名和密码
//1、获取连接
Connection connection=JdbcUtils.getConnection();
//2、创建预编译对象
PreparedStatement preparedStatement=connection.prepareStatement(sql);
//3、替换替换符内容
preparedStatement.setString(1,username);
preparedStatement.setString(2,password);
//4、执行SQL得到结果集
ResultSet resultSet=preparedStatement.executeQuery();
//5、得到是否登录成功，成功就是为true,失败为False
boolean isval = false;
if(resultSet.next()){
isval = true;
}
//6、释放资源
JdbcUtils.closeAll(resultSet,preparedStatement,connection);
if(isval){
System.out.println("登录成功！");
}else{
System.out.println("登录失败！");
}
}
}
回顾：
CRUD-PreparedStatement预编译执行SQL
JDBC事务
开启事务 connction.setAutoCommit(false);
提交事务connection.commit();
回滚事务connection.rollback();
1、读取配置文件
}
Properties类
InputStream inputStream=JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
ResourceBundle类
package com.ww.jdbc_demo_01.util;
import java.sql.*;
import java.util.ResourceBundle;
public class JdbcUtils {
//1、读取配置文件里面的属性值
//1-1、声明读取的属性值要赋值的变量
private static String driver;
private static String url;
private static String username;
private static String password;
//1-2、静态代码块，读取配置文件；加载驱动；
static{
//1、读取resources/jdbc.properties配置文件
ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
driver=bundle.getString("driver");
url=bundle.getString("url");
username= bundle.getString("username");
password=bundle.getString("password");
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
//2、获取连接
public static Connection getConnection(){
Connection connection= null;
try {
connection = DriverManager.getConnection(url,username,password);
} catch (SQLException e) {
throw new RuntimeException(e);
}
return connection;
//3、释放资源
public static void closeAll(ResultSet resultSet, Statement statement, Connection connection){
try {
if(resultSet!=null){
resultSet.close();
}
if(statement!=null){
statement.close();
}
if(connection!=null){
connection.close();
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
2、连接池
2.1、连接池概述
2.1.1、为什么要去使用连接池
存放多个连接的容器。
我会频繁的使用连接，一个连接从创建到销毁都会消耗我们的资源。
同时创建多个连接，存入集合，使用获取集合中没有被使用的连接，使用完后就将连接归还给集合。
2.1.2、连接池原理
如果连接池中基础连接被获取完了，要么等待3S，看是否有连接归还；如果没有就只能新建连接。
自定义连接池，使用的是LinkedList集合来存放我们的连接。
3、自定义连接池
创建类，连接池类（MyDataSource.java）
定义一个集合对象（LinkedList.java）
初始化连接，5个、10个
获取连接
归还连接
package com.ww.jdbc_demo_01.util;
import java.sql.Connection;
import java.util.LinkedList;
//1、新建连接池类
public class MyDataSource {
//2、创建连接池
private LinkedList<Connection> connectionPool=new LinkedList<Connection>();
//3、初实始化5个连接
public MyDataSource(){
for(int i=1;i<=5;i++){
//创建5个连接
Connection connection=JdbcUtils.getConnection();
connectionPool.add(connection);
}
}
//4、获取连接,还有初始化好的连接就获取，没有子就创建新的连接
public Connection getConnection(){
Connection connection=null;
if(connectionPool.size()>0){
connection =connectionPool.removeFirst();
}else{
connection=JdbcUtils.getConnection();
}
return connection;
}
//5、归还连接,就是将使用完的连接，在次存入到我们的连接池对象
public void addBack(Connection connection){
connectionPool.addLast(connection);
}
}
连接池使用
@Test
public void selectAllUser() throws SQLException {
//1、查询所有SQL语句
String sql="select * from user";
//2、获取连接
MyDataSource myDataSource=new MyDataSource();//new 时已经初始化有5个连接
Connection connection=myDataSource.getConnection();//获取连接
//3、创建PreparedStatement对象
PreparedStatement preparedStatement=connection.prepareStatement(sql);
//4、替换替换符(无参数)
//5、执行SQL，拿到结果集
ResultSet resultSet=preparedStatement.executeQuery();
//6、取出结果集，存入到实体类；实体类存入到集合
List<User> list=new ArrayList<User>();
while(resultSet.next()){
User user=new User();
user.setId(resultSet.getInt("id"));
user.setUsername(resultSet.getString("username"));
user.setPassword(resultSet.getString("password"));
user.setNickname(resultSet.getString("nickname"));
list.add(user);
}
//7、释放资源,归还连接给连接池
JdbcUtils.closeAll(resultSet,preparedStatement,null);
myDataSource.addBack(connection);
//8、集合处理，（1）返回return （2）打印输出了
for(User user:list){
System.out.println(user.toString());
}
}
package jdbc.Test;
import jdbc.Utils.jdbc_Utils;
import org.junit.Test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;
public class jdbc_login {
public static void main(String args[]) throws SQLException {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入账号：");
String username = scanner.next();
System.out.println("请输入密码：");
String password = scanner.next();
String sql = "select * from user where username =? and password =?";
Connection connection = jdbc_Utils.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1,username);
preparedStatement.setString(2,password);
ResultSet resultSet = preparedStatement.executeQuery();
boolean isval = false;
if (resultSet.next()){
isval = true;
}
jdbc_Utils.closeAll(resultSet,preparedStatement,connection);
if (isval){
System.out.println("登陆成功！");
}else {
System.out.println("登录失败！");
}
}
}
package com.ww.jdbc;
import com.ww.jdbc_demo_01.javabean.user;
import java.nio.file.attribute.UserPrincipal;
import java.sql.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class jdbc_demo2 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//加载驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//连接数据库
String url ="jdbc:mysql://localhost:3306/ooo";
String username = "root";
String password = "123456";
Connection connection = DriverManager.getConnection(url,username,password);
String sql = "select * from user";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql);
//循环打印输出所有结果集 或者 将所有的结果集存入对象，存入对象后和返回，可读取
List<user> list = new ArrayList<user>();
while (resultSet.next()){
// System.out.println(resultSet.getObject("id"));
// System.out.println(resultSet.getObject("username"));
// System.out.println(resultSet.getObject("password"));
// System.out.println(resultSet.getObject("nickname"));
user user = new user();
user.setId(resultSet.getInt("id"));
user.setUsername(resultSet.getString("username"));
user.setPassword(resultSet.getString("password"));
user.setNickname(resultSet.getString("nickname"));
list.add(user);
}
//循环打印
for (user u:list){
System.out.println(u.toString());
}
//迭代方式打印
Iterator<user> iterator = list.iterator();
while (iterator.hasNext()){
user next = iterator.next();
System.out.println(next);
}
//释放资源（先创建，后关闭）
resultSet.close();
statement.close();
connection.close();
}
}
package com.ww.jdbc_demo_01.javabean;
public class user {
//将所有的属性私有化
private int id ;
private String username;
private String password;
private String nickname;
//为了产生实体类对象，构造方法必须有无参和全参
public user() {
}
public user(int id, String username, String password, String nickname) {
this.id = id;
this.username = username;
this.password = password;
this.nickname = nickname;
}
//想要存储属性的值，通过get/set方法
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 getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
//@Override注解
@Override
public String toString() {
return "user{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
import com.mysql.jdbc.Driver;
import java.sql.*;
public class jdbc_demo1 {
public static void main(String[] args) throws SQLException {
//加载驱动
DriverManager.registerDriver(new Driver());
//连接数据库
String url ="jdbc:mysql://127.0.0.1:3306/ooo";
String username = "root";
String password = "123456";
Connection connection = DriverManager.getConnection(url, username, password);
//操作数据表
String sql ="select * from user";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql);
while (resultSet.next()){
System.out.println(resultSet.getObject(1)+" ");
System.out.println(resultSet.getObject(2)+" ");
System.out.println(resultSet.getObject(3)+" ");
System.out.println(resultSet.getObject(4)+" ");
System.out.println();
}
resultSet.close();
statement.close();
connection.close();
}
}
package com.ww.jdbc.Test;
import com.ww.jdbc.Utils.jdbc_Utils;
import com.ww.jdbc_demo_01.javabean.user;
import org.junit.Test;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class jdbc_Utils01 {
// @Test
// public void jdbcutilselect() throws SQLException {
// String select_sql = "select * from user";
// Connection connection = jdbc_Utils.getConnection();
// Statement statement = connection.createStatement();
// ResultSet resultSet = statement.executeQuery(select_sql);
// List<user> users = new ArrayList<>();
//
// while (resultSet.next()) {
// user user = new user();
// user.setId(resultSet.getInt("id"));
// user.setUsername(resultSet.getString("username"));
// user.setPassword(resultSet.getString("password"));
// user.setNickname(resultSet.getString("nickname"));
// users.add(user);
// }
// for (user i : users) {
// System.out.println(i.toString());
// }
//
// jdbc_Utils.closeAll(resultSet,statement,connection);
//
// }
// @Test
// public void jdbcutilselect01() throws SQLException {
// String select_sql = "select * from user where id = 1";
// Connection connection = jdbc_Utils.getConnection();
// Statement statement = connection.createStatement();
// ResultSet resultSet = statement.executeQuery(select_sql);
// List<user> users = new ArrayList<>();
//
// while (resultSet.next()) {
// user user = new user();
// user.setId(resultSet.getInt("id"));
// user.setUsername(resultSet.getString("username"));
// user.setPassword(resultSet.getString("password"));
// user.setNickname(resultSet.getString("nickname"));
// users.add(user);
// }
// for (user i : users) {
// System.out.println(i.toString());
// }
//
// jdbc_Utils.closeAll(resultSet, statement, connection);
//
// }
@Test
public void jdbcdelete() throws SQLException {
String delete_sql = "delete from user where id = 3";
Connection connection = jdbc_Utils.getConnection();
Statement statement = connection.createStatement();
statement.executeUpdate(delete_sql);
jdbc_Utils.closeAll(null, statement, connection);
}
}
扫一扫
7607
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
