第六周总结

最新推荐文章于 2024-07-20 23:55:03 发布

殿.

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量81

点赞数

文章标签： udp java 网络

本文链接：https://blog.csdn.net/qq_52963115/article/details/128163394

版权

11-28

1.UDP发送端可以不断键盘录入数据,接收端不断展示数据,发送端可以自定义结束条件

package com.qf.text1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.*;

//1.UDP发送端可以不断键盘录入数据,
// 接收端不断展示数据,发送端可以自定义结束条件 (课堂练习)
public class UdpSend {
    public static void main(String[] args) {
        //udp发送端可以不断键盘录入数据
        //创建发送端的socket
        DatagramSocket ds=null;
        try{
            ds=new DatagramSocket();
        //键盘录入可以使用BufferedReader--->读一行
            BufferedReader br=new BufferedReader(
                    new InputStreamReader(System.in));
            String line=null;
            //一次读一行内容
            System.out.println("请你输入一个数据:");
            while ((line= br.readLine())!=null){
                //输入over,结束程序
                if ("over".equals(line)){
                    break;
                }
                //创建数据报包,将数据存储在数据包中
                DatagramPacket dp = new DatagramPacket(line.getBytes(),
                        line.getBytes().length,
                        InetAddress.getByName("10.35.162.122"),
                        3333);
                //发送数据报包
                ds.send(dp);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (ds!=null){
                ds.close();
            }
        }
    }
}

package com.qf.text1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

//接收端不断接收数据
public class UdpReceive {
    public static void main(String[] args) {
        //创建socket对象
        try{
            DatagramSocket ds=new DatagramSocket(3333);
            while (true){
                //创建一个接收容器
                //自定义一个字节数组缓冲去
                byte[] buffer=new byte[1024];
                int bufferLength=buffer.length;
                DatagramPacket dp=new DatagramPacket(buffer,bufferLength);
                //接收数据容器
                ds.receive(dp);
                //读取接收容器中的真实内容

                byte[]bytes= dp.getData();
                int length = dp.getLength();
                //每次从0开始读取字节数---转成String
                String receiveMsg=new String(bytes,0,length);
                //获取ip地址字符串
                String ip=dp.getAddress().getHostAddress();
                //展示数据
                System.out.println("数据来自:"+ip+",接收到:"+receiveMsg);
            }
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.TCP客户端和服务端的代码实现

1.)TCP 客户端使用步骤

创建客户端的Socket对象,指定ip和接口

获取客户端通道内字节输入流对象,写数据

释放资源

package com.qf.text2;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class TcpClientDemo {
    public static void main(String[] args) throws IOException {
        //创建Socket对象,指定ip和端口
        Socket s=new Socket("10.35.162.122",2222);
        //获取客户端通道内容字节输入流对象,写数据
        OutputStream outputStream = s.getOutputStream();
        outputStream.write("hello,TCP我来了!".getBytes());
        //客户端获取通道内字节输入流对象,读服务器端的反馈的数据
        InputStream inputStream= s.getInputStream();
        byte[]bytes=new byte[1024];
        int length= inputStream.read(bytes);
        //转换成字符串类型
        String fkMsg=new String(bytes,0,length);
        System.out.println(fkMsg);
        //释放资源
        outputStream.close();

    }
}

2.)TCP服务器端的代码实现

创建服务器端的Socket

监听客户端的连接

获取监听到的客户端的通道内的字节输入流对象,读数据

释放服务器端的资源

package com.qf.text2;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务器端
public class TcpServerDemo {
    public static void main(String[] args) throws IOException {
        //创建Socket对象
        ServerSocket ss=new ServerSocket(2222);
        System.out.println("服务器正在等待客户端连接请求...");
        //监听客户端的连接
        //阻塞方法,没有客户端连接,一直等待
        Socket socket = ss.accept();
        System.out.println("客户端已经连接");
        //获取监听到的字符流对象,读数据
        InputStream in=socket.getInputStream();
        //一次读取一个数组
        byte[]bytes=new byte[1024];
        int length=in.read(bytes);
        //转换成String
        String receiveMsg=new String(bytes,0,length);
        //获取IP地址对象,同时ip地址字符串形式
        String ip=socket.getInetAddress().getHostAddress();
        System.out.println("数据来自:"+ip+",接收到:"+receiveMsg);
        OutputStream outputStream=socket.getOutputStream();
        //反馈
        outputStream.write(bytes);
        //释放资源
       ss.close();

    }
}

3.TCP三次握手原理--->SYNC+ACK

SYNC同步序列编号

ACK:消息确认字符(当客户端发送数据到服务器端,服务器需要确认并反馈)

4.TCP的应用

4.1TCP方式,客户端可以不断键盘录入数据,服务器端不断展示数据

public class TcpClient {
    public static void main(String[] args) throws IOException {
        //1)创建客户端Socket
        Socket socket  = new Socket("10.35.162.121",8888) ;

        //2)可以创建BufferedReader 一次读取一行,录入数据
        BufferedReader br=  new BufferedReader(new InputStreamReader(System.in)) ;
        //获取通道字节输出流对象,写数据--->字节输出流---->包装字符流
        OutputStream out = socket.getOutputStream();
        //可以使用字符流把上面的通道内的字节数出流包装
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out)) ;
        String line = null ;
        while((line=br.readLine())!=null){
            /*if("886".equals(line)){
                break;
            }*/
            //录入一行,给封装到通过的字符流写一行进去
            bw.write(line) ;
            bw.newLine();
            bw.flush();
        }

        socket.close();

    }
}

public class TcpServer {
    public static void main(String[] args) throws IOException {

        //创建服务器端的Socket
        ServerSocket ss = new ServerSocket(8888) ;
        System.out.println("服务器正在等待连接");
       // int i= 0 ;
        while (true){//监听多个客户端了解
         //   i++;
            //监听客户端连接
            Socket socket = ss.accept();
          //  System.out.println("第"+i+"个客户端已连接");
            //获取监听客户端所在的通道内的字节输入流
            InputStream in = socket.getInputStream();
            //将桶内的字节输入流封装成字符流读
            BufferedReader br = new BufferedReader(new InputStreamReader(in)) ;
            //一次读取一行
            String line = null ;
            while((line=br.readLine())!=null){
              if("886".equals(line)){
                  break;
              }
                System.out.println(line) ;//展示数据
            }
        }

        //模拟真实场景,服务器端不关

    }
}

4.2 TCP客户端的读取文本文件(将文本文件写入通道中)_,

服务器端复制文本文件到指定路径中(将文本文件写入指定文件中)

package com.qf.text3;

import java.io.*;
import java.net.Socket;

//	3)TCP客户端图片文件,服务器端对图片文件复制
public class TcpClientDemo {
    //客户端
    public static void main(String[] args) throws IOException {
        //创建客户端的socket对象
        Socket socket=new Socket("10.35.162.122",2222);
        //创建字符缓冲流输入对象
        BufferedReader br=new BufferedReader(new FileReader("夕阳.jpg"));
        //创建客户端通道的字节输出流---->包装成BufferWriter:字节缓冲输出流
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        //读取
        String line=null;
        while ((line= br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        socket.shutdownOutput();
        //客户端读取并反馈数据
        //获取通道内的字节输出流
        InputStream inputStream=socket.getInputStream();
        //读取一个字节数组的方式
        byte[] bytes=new byte[1024];
        int len=inputStream.read(bytes);
        System.out.println("客户端接受到了反馈数据"+new String(bytes,0,len));
        //释放资源
        br.close();
        bw.close();
    }
}

package com.qf.text3;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpSeverDemo {
    //服务端
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象
        ServerSocket ss=new ServerSocket(2222);
        Socket s= ss.accept();
        BufferedReader br=new BufferedReader(
                new InputStreamReader(s.getInputStream())
        );
        BufferedWriter bw=new BufferedWriter(new FileWriter("E:\\idea_project\\day31\\copy.jpg"));
        String line=null;
        while ((line= br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        OutputStream out =s.getOutputStream();
        out.write("hello,文件复制完毕".getBytes());
        out.flush();
        bw.close();
        ss.close();

    }
}

4.3 TCP客户端读取文本文件,服务器端复制文本文件,现在服务器端反馈给客户端,"已经复制完毕"

public class Tcp_ClientTest2 {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象
        Socket s = new Socket("10.35.162.121",2222) ;
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(
                new FileReader("UdpReceive.java")) ;

        //获取客户端通道的字节输出流---->包装成BufferedWriter:字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(
                new OutputStreamWriter(s.getOutputStream())) ;

        //每次从.java文件读取一行,给通道流的流中写一行
        String line = null ;
        while((line=br.readLine())!=null){//阻塞式方法.一直等待为null文件完毕
            bw.write(line) ;
            bw.newLine();
            bw.flush();
        }

        //写一个数据
        //通道内的流写一句
       /* bw.write("over");
        bw.newLine();
        bw.flush();*/


        //方案2: public void shutdownOutput()   throws IOException
        s.shutdownOutput();


        //客户端要读取服务器反馈数据
        //获取通道内的字节输入流
        InputStream inputStream = s.getInputStream();
        //读取一个字节数组
        byte[] bytes = new byte[1024] ;
        int len = inputStream.read(bytes);
        System.out.println("客户端接收到了反馈数据:"+new String(bytes,0,len));


        //释放资源
        br.close();
        s.close();
    }

}

public class Tcp_ServerTest2 {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象
        ServerSocket ss = new ServerSocket(2222) ;
        //监听客户端连接
        Socket s = ss.accept();
        //获取监听客户端所在的通道内字节输入流对象---->包装成字符缓冲输入流
        BufferedReader br = new BufferedReader(
                new InputStreamReader(s.getInputStream())) ;

        //将监听客户端的通道内的字节流(已经被包装了字符缓冲输入流)的内容----通过的字符缓冲输出流写入到文件中
        BufferedWriter bw = new BufferedWriter(
                new FileWriter("D:\\EE_2211\\day27_code_resource\\copy.java")) ;
        //一次读取一行,写一行到文件中
        String line = null ;
        while((line=br.readLine())!=null){//阻塞式,null也是表示客户端的通道内的字节输入流读完了

          /*  if("over".equals(line)){
                break;
            }*/
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //加入反馈,服务器端反馈给客户端数据
        //获取字节输出流,写
        OutputStream out = s.getOutputStream();
        out.write("hello,文件复制完毕".getBytes());
        out.flush();

        //释放资源
        bw.close();
        ss.close();


    }
}

5.反射

反射获取构造器并创建当前类实例

public class Person {
    private String name ; //私有的成员班里
    public int age ; //年龄
    String gender ; //性别

    //构造方法
    public Person(){}//无参构造方法
    private Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    Person(String name,int age,String gender){
        this.name = name ;
        this.age = age ;
        this.gender = gender ;
    }

    //成员方法
    //没有返回值,无参
    public void show(){
        System.out.println("show Person");
    }
    //没有返回值,带参
    private void method(String str){
        System.out.println(str);
    }
    //有返回值.不带参
    private String function(){
        return "helloJavaEE" ;
    }
    //有返回值,带参
     String myFunction(int num){
        return "今晚韩国对阵加纳总球数是"+num ;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

通过反射方式获取类的字节码文件之后,创建当前类对象!

1.)获取类的字节码文件

2.)获取类的Constructor所在的构造器对象

3.)通过它创建当前类的实例

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //之前的写法:通过无参构造方法创建对象
        //类名 对象名  = new 类名() ;
       // Person person = new Person() ;
       // System.out.println(person);
        System.out.println("-----------------------------------------------");

        //通过反射获取构造器(Constructor)对象--->创建当前类实例
        //1)获取类的字节码文件对象
        Class clazz = Class.forName("com.qf.reflect_06.Person") ;
        //2)获取类的Constructor所在的构造器对象
       // public Constructor<?>[] getConstructors()获取这个类中所有的公共的构造函数
       // Constructor[] constructors = clazz.getConstructors();
        //public Constructor<?>[] getDeclaredConstructors()获取这个类中所有的构造函数
       /* Constructor[] constructors = clazz.getDeclaredConstructors();
        for(Constructor con:constructors){
            System.out.println(con);
        }*/

        //2)获取指定的构造方法所在的Constructor类对象
        //public Constructor<T> getConstructor(Class<?>... parameterTypes)
        //获取指定的公共的构造方法所在Constructor实例,参数--->参数类型的Class字节码文件对象
        //参数是String----->String.class----结果 java.lang.String
        Constructor con = clazz.getConstructor();// clazz.getConstructor(String.class)
        //System.out.println(con);
        //3)通过它创建当前类实例
        //public T newInstance(Object... initargs):参数就给构造函数中参数进行实际赋值
        Object obj = con.newInstance();
        System.out.println(obj);

    }
}

给成员赋值

public class ReflectDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

        //Person p = new Person("高圆圆",44) ;  //之前的代码不行,私有构造方法不能new
        //现在反射方式通过构造方法赋值
        //1)获取当前类的字节码文件对象
        Class clazz = Class.forName("com.qf.reflect_06.Person");
        //2)获取构造器Constructor类对象--->带两个参数的
        //public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
        //参数里面是参数类型的字节码文件对象
        Constructor con = clazz.getDeclaredConstructor(String.class, int.class);
       // System.out.println(con);//private com.qf.reflect_06.Person(java.lang.String,int)

        //AccessibleObject类提供Field(成员变量的类对象)/Method(成员方法类对象)/Constructor(构造器类对象)的基类
        //提供功能:取消Java语言访问检查,暴力访问
        //public void setAccessible(boolean flag) true:就是抑制Java语言访问检查功能
        con.setAccessible(true);

        //通过它创建当前类实例
        Object obj = con.newInstance("高圆圆", 44);//IllegalAccessException:当前构造器私有不能访问
        System.out.println(obj);
    }
}

反射获取成员方法并调用

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        //之前的写法
       // Person p = new Person();
        //p.show() ;
        System.out.println("----------------------------------");

        //反射的写法
        //1)获取类的字节码文件对象
        Class clazz = Class.forName("com.qf.reflect_06.Person") ;



        //2)通过无参构造器创建器Constructor创建当前类实例
        //如果你这个类没有提供任何构造方法(系统提供无参)或者无参构造方法是公共的---->此时可以直接使用Class类的newInstacne()创建当前类实例
        //等价于下面这个写法
        Object obj = clazz.newInstance();
        System.out.println(obj);
        //System.out.println(obj);

        /*Constructor con = clazz.getConstructor();
        Object obj = con.newInstance() ;*/
       // System.out.println(obj);


        // Method getMethods() ;//获取本类中所有的成员的method
        // Method getDeclaredMethods() ;//获取本类中所有的成员的method以及父类的Object

        //3)获取指定的成员方法所在的Method类对象
       // public Method getDeclaredMethod(String name, Class<?>... parameterTypes)获取指定的成员方的method类对象
       // public Method getMethod(String name, Class<?>... parameterTypes):获取指定的公共的成员方法的Method对象
       //第一个参数都是方法名
        //第二个参数是可变参数,方法的形式参数类型的Class(字节码文件对象)

        Method method = clazz.getMethod("show");//方法本身就是空参
        System.out.println(method);
        //调用方法,Method类---提供的invoke
        //public Object invoke(Object obj, Object... args)
        //第一个参数:当前类实例
        //第二个参数:给方法的形式参数赋的实际参数
        //调用方法到时候将指定的方法实际参数作用在当前类实例上
        method.invoke(obj) ; //本身这个方法没有返回值,单独调用

        System.out.println("----------------------------------------------------------");
        /**
         * 反射调用这个
         * private void method(String str){
         *         System.out.println(str);
         *     }
         */
        Method m1 = clazz.getDeclaredMethod("method", String.class);
       // System.out.println(m1);//private void com.qf.reflect_06.Person.method(java.lang.String)
        //私有方法取消Java语言检查
        m1.setAccessible(true) ;
        m1.invoke(obj,"hello,高圆圆") ;


    }
}

11-29

1.什么是数据库?

数据库就是存储数据的一种仓库!

早期存储数据---->临时变量(局部变量)---->随着方法调用而存在,随着方法调用结束而消失

后面-------->成员变量(非静态) ----->随着方法对象的创建而存在,随着对象的创建完毕等待垃圾回收器回收而消失容器---->数组---->长度固定(弊端)

--->StringBuffer--->字符串缓冲区存储各种字符序列,它长度可变,但StringBuffer使用完毕等待回收

--->集合--->长度可变,它可以存储任何引用类型的数据,使用完毕--->也要被回收掉

--->IO流--->永久存储,但是IO流太耗时了

数据库存储数据

1.)存储空间非常大,用户可以对数据库中的内容进行增删查改

2.)数据独立性高

3.)实现数据共享

4.)减少数据的冗余度

5.)通过数据库里面的"事务"--->实现数据的一致性以及维护性;

2.市面上常见的数据库

关系型数据库

MySQL,SqlSever,Oracle,MariaDB

非关系型数据库

Redis,Memcache,MongoDb,HBase

3.DDL语句的基础语法---库的操作

1.)查询所有库 show databases;

2.)创建库

create database if not exists 库名;如果没有这个库,则创建库

直接创建库 create database 库名;

3.)查询指定库的信息--包括它的字符集

show create database 库名;

4.)修改库的字符集

alter database 库名 default character set 字符集格式;

5.)删除库

drop database if exists 库名;如果存在库名,则删除

drop database 库名;直接删除库

4.DDL语句的基础语法---表的操作

创建表的前提----->必须使用库(库就是文件夹)

use 库名;

mysql常见的数据类型

int varchar(字符长度) date:日期类型--->仅仅表示日期

datetime:日期+时间

timestap:修改时间数据

double:小数类型

clob:大字符类型,某个表中某个字段--->使用clob来存储大文本!

blob:大字节类型:存储大图片文件--->大字节类型

查询库中有那些表

show tables;

创建表的语法
create table 表名(

字段名称1 字段类型1,

字段名称2,字段类型2

);

查询表的结构

desc 表名;

修改表的字段类型

alter table 表名 modify 字段名称修改后字段类型;

修改字段名称

alter table 表名 change 以前的字段名称现在的字段名称以前的字段类型;

修改表--->添加一个新的字段

alter table 表名 add 字段名称字段类型;

修改表---删除表中某个字段

alter table 表名 drop 字段名称;

修改表名

alter table 表名 rename to 新表名;也可以rename table 以前表名 to 新表名;

查询表的字符集

show create table 表名;

修改表的字符集

alter table 表名 character set 字符集格式;

create table 新表名 like 旧表名

删除表

drop table if exits 表名;如果存在,就删除

drop table 表名;直接删除

12-1

1.MySQL的DQL语句--->数据库查询语句(带条件查询分类)

模糊查询

select 字段列表 from 表名 where like '%xx%';

%:代表任意多个字符

_:代表任意一个字符

聚合查询

count(字段名称)

max(列名称):求最大值

min(列名称):求最小值

avg(列名称):求当前列的平均值

sum(列名称):求当前列的总和

排序查询

select 字段列表 from 表名 order by 字段名称排序规则;

默认asc 升序

desc 降序

分组查询

select 字段列表 from 表名 group by 分组字段名称;

where条件和group by,where条件的在group by的前面

group by的后面不能使用where,先满足where条件,才参与分组!

筛选

having的后面可以跟聚合函数,having在group by后面,where在group by前面

分页查询

select 字段列表 from 表名 limit 起始行数,每页显示的条数

2.数据库约束

默认约束 default

非空约束 not null

唯一约束 unqiue

主键约束 primary key--->非空且唯一

自增长约束+ 上面的约束--->每一张表的id

级联操作:需要上面的有关联关系需要用级联
部门表和员工表
操作主表的数据,从表数据随之更改

3.关于表和表的关系/数据库的三大范式(设计数据库)

第一范式1NF :表中的每一列是单独的,不能再拆分
第二范式2NF:在满足1NF的基础上
非主键字段必须完全依赖于主键字段
第三范式3NF:在满足2NF的基础上
非主键字段中间不能产生传递依赖

4.多表查询

1.)子查询

select 嵌套 select.....

情况1:单行单列的数据

情况2:多行多列

情况3:通过两个表的关系----查询出结果集--->当作虚表在和其他之间关联拆线呢!

笛卡尔乘积:多表查询语法select 字段列表 from 表名1,表名2;

这个就是笛卡尔乘积,针对A表的记录和B的记录数,两个表的记录相乘
出现笛卡尔乘积的原因:没有设置连接条件!

多表查之内连接()
隐式内连接:where条件---多去使用这种查!
   select
       字段列表
from
       表名1,表名2...表名n
   where
       这些表之间的连接条件;

内连接---显示内连接 (inner可以省略) join
   select
       字段列表
   from 表名1
   (inner) join
   表名2
   on 连接条件;

外连接
左外连接(通用)
将A表(左表)的和B表(右表)的交集以及A表(左表)中所有数据全部查询!
   select
   字段列表
   from
       左表名
   left (outer) join -- outer可以省略
           -- righter (outer) join 可以右外连接
   表名2
   on
       连接条件;

12-3

什么是事务(Transaction)

在一个业务中执行多个SQL(多张表的SQL),这多个SQL语句要么同时执行成功,要么同时执行失败

事务特点 ACID (关系型数据库传统事务)

原子性,一致性,隔离性,持久性!

原子性:在使用事务管理的时候,执行多个sql增删改,要么同时执行成功,要么同时失败
一致性:高并发的时候,需要保证事务多次读写,保证数据一致性!
隔离性:事务和事务是独立的,相互不影响!
           举例
               购物车业务--->购物车表和购物车项表同时添加数据
               订单业务---->订单表和订单项表同时添加数据
持久性:   事务一旦提交,对数据的影响是永久性,即使关机了,数据还是要更新的!

事务的隔离级别

四个级别:从小到大,安全性---从低到高,效率性:从高到低!

read uncommitted :读未提交

read committed :读已提交
repeatable read :可重复读 (mysql的默认隔离级别)
serializable : 串行话

设置隔离级别

set global transaction isoloation level 级别的名称;

第一种级别read uncommitted:读未提交会造成问题"脏读"

"脏读":是事务管理最严重的问题:一个事务读取到另一个没有提交的事务!

第二种级别:read committed; 读已提交有效防止脏读,出现了一个问题"不可重复读"
事务(当前本身这个事务提交)多次读取另一个提交事务的前后得到的数据不一致!

mysql的默认级别 repeatable read
可重复读,有效脏读,不可重复读,出现幻读!(一般有更新操作影响了数据)

最高级别:serializable:串行话 (一个事务读取到另一个没提交事务,数据查不到的,这个必须提交,才能操作数据!)

Jdbc的引入

七大步骤

1.)导报驱动包

2.)注册驱动---加载驱动类

3.)获取数据库的连接对象java.sql.Connection

4.)准备sql语句

5.)通过Connection连接对象获取数据库的执行对象

6.)执行sql语句

7.)释放资源

public class JdbcDemo {
    public static void main(String[] args) throws Exception {
        
        //Jdbc的操作:java连接数据库
        //1)导入驱动jar包
        //2)注册驱动---加载驱动类
        Class.forName("com.mysql.jdbc.Driver") ; //mysql5.5或者5.1的jar包:都是这个全限定名称
                                                //mysql8.0jar包: com.mysql.cj.jdbc.Driver

        //3)获取数据库连接对象
        //DriverManager驱动管理类--->
        //public static Connection getConnection(String url, 连接库地址  (统一资源定位符)
        //                                       String user, mysql的用户名  root用户
        //                                       String password) 登录MySQL的密码
        //                                throws SQLException

        //url--->组成: 协议名称 ://域名:端口号/具体的路径
        /*
        * mysql的驱动jar包如果是8.0以后:url的后面           编码格式         是否启用证书登录     服务器时区         是否公钥模式
        * jdbc:mysql://localhost:3306/ee_2211_02?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
        * */

        //  jdbc:mysql://localhost:3306/库名
        Connection conn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/ee_2211_02",
                "root",
                "123456"
        );

        //4)准备sql语句
        String sql = "insert into account (name,balance) values('高圆圆',1000)" ;

        //5)通过数据库连接对象Connection获取数据库的执行对象
        //执行静态sql语句
        //Statement createStatement()throws SQLException创建一个Statement对象，用于将SQL语句发送到数据库
        Statement stmt = conn.createStatement();

        //6)执行sql语句
        //Statement--->
        //int executeUpdate(String sql)throws SQLException 通用的更新操作
        int count = stmt.executeUpdate(sql);
        System.out.println("影响了"+count+"行");

        //7)释放资源
        stmt.close();
        conn.close();

    }
}