网络编程_反射_数据库的操作及连接

一、网络编程

1.网络编程的三要素

ip: 使用点分十进制法,中间使用.隔开
	A类  国家大部门---->前一个号段是网络号段,后面三个主机号段
	B类  校园/大公司服务器机房/:前面两个网络号段,后面使用两个注解号段
	C类  私人地址:前面三个为网络号段,后面是主机号段
port端口:
	port端口 360软件都可以查看你电脑所有客户端软件的端口号
	范围:0~65535  里面0~1024属于保留端口
传输协议:
	UDP协议--->数据报包(数据包的报文)
		1)不需要建立连接通道
		2)不可靠协议,不安全的
		3)发送数据大小有限制
	TCP协议--->最基本的字节流的方式发送数据
		1)就必须连接通道
		2)可靠协议,一种安全
		3)发送数据大小无限制

2.UDP发送端和接收端的实现(了解) —>不可靠连接

基本UDP的发送端和接收端代码实现

发送端:

		//1)创建接收端的Socket对象,绑定端口       
        DatagramSocket ds = new DatagramSocket(10086) ;

        //2)创建一个接收容器--->数据包--->自定义字节缓冲区,将发送的数据包
        byte[] bytes = new byte[1024] ;//1024或者1024整数倍
        int length = bytes.length ;
        DatagramPacket dp = new DatagramPacket(bytes,length) ; //将发送端数据缓冲到这个接收容器中

        //3)接收,以上面这个接收容器来接收
        ds.receive(dp);

        //4)从接收容器中解析数据包的实际内容数据
        //从接收容器中获取public byte[] getData() 实际缓冲区的对象(从上bytes分段取数据)
        byte[] bytes2 = dp.getData();
        //获取里面实际缓冲区的长度
       // public int getLength()
        int length2 = dp.getLength();
        //展示数据---分段取数据,每次从0开始取实际长度
        String msg = new String(bytes2,0,length2) ;
        //数据包里面获取哪一个ip地址发来的--->ip地址字符串形式
        String ip = dp.getAddress().getHostAddress() ;
        System.out.println("data from --->"+ip+",发送内容是:"+msg);

        //释放资源
        ds.close();

接收端:

		//1)创建接收端的Socket对象,绑定端口       
        DatagramSocket ds = new DatagramSocket(10086) ;

        //2)创建一个接收容器--->数据包--->自定义字节缓冲区,将发送的数据包
        byte[] bytes = new byte[1024] ;//1024或者1024整数倍
        int length = bytes.length ;
        DatagramPacket dp = new DatagramPacket(bytes,length) ; //将发送端数据缓冲到这个接收容器中

        //3)接收,以上面这个接收容器来接收
        ds.receive(dp);

        //4)从接收容器中解析数据包的实际内容数据
        //从接收容器中获取public byte[] getData() 实际缓冲区的对象(从上bytes分段取数据)
        byte[] bytes2 = dp.getData();
        //获取里面实际缓冲区的长度
       // public int getLength()
        int length2 = dp.getLength();
        //展示数据---分段取数据,每次从0开始取实际长度
        String msg = new String(bytes2,0,length2) ;
        //数据包里面获取哪一个ip地址发来的--->ip地址字符串形式
        String ip = dp.getAddress().getHostAddress() ;
        System.out.println("data from --->"+ip+",发送内容是:"+msg);

        //释放资源
        ds.close();

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){
                if ("over".equals(line)){
                    break;
                }
                //创建数据报包,将数据存储在数据包中
                DatagramPacket dp = new DatagramPacket(line.getBytes(),
                                                       line.getBytes().length,
                                                        InetAddress.getByName("127.0.0.1"),
                                                        6666);
                //发送数据报包
                ds.send(dp);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(ds!=null){
                ds.close();
            }
        }

接收端:

 try {
            //创建接收端的Socket对象
            DatagramSocket ds = new DatagramSocket(6666);

            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("data from"+ ip + ",count is"+ receiveMsg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

3.TCP客户端和服务器端的实现---->安全—可靠连接

基本TCP的服务端和客户端端代码实现

客户端:

		//1)创建客户端的Socket对象,指定ip和端口    
        Socket socket = new Socket("10.35.162.121",1888) ;
        //2)获取客户端通道内容字节输出流对象,写数据        
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,TCP我来了".getBytes());

        //客户端获取通道字节输入流对象,读服务器端的反馈的数据
        InputStream in = socket.getInputStream();
        byte[] bytes = new byte[1024] ;
        int length = in.read(bytes);
        String fkMsg = new String(bytes,0,length) ;
        System.out.println(fkMsg);

        //3)释放资源
        outputStream.close();

服务端:

        //1)创建服务器端的Socket对象
        ServerSocket ss = new ServerSocket(1888) ;
        System.out.println("服务器正在等待客户端连接请求...");
        //2)监听客户端的连接
        Socket socket = ss.accept();//阻塞式方法,没有客户端连接,一直等待
        System.out.println("客户端已连接");

        //3)获取监听到的客户端的通道内的字节输入流对象,读数据
        InputStream inputStream = socket.getInputStream();
        //一次读取一个字节数组
        byte[] bytes = new byte[1024] ;
        int length = inputStream.read(bytes);
        //转换成String
        String receiveMsg =  new String(bytes,0,length) ;

        //获取ip地址对象,同时ip地址字符串形式
        String ip = socket.getInetAddress().getHostAddress();
        System.out.println("data from --->"+ip+",content is-->"+receiveMsg);

        //服务器端反馈给客户端数据
        //服务器端可以获取监听客户端通道内字节输出流,写数据
        OutputStream out = socket.getOutputStream();
        out.write("我这边已经收到数据!".getBytes());

		//4)释放服务器端的资源
        ss.close();

TCP客户端不断键盘录入数据,服务器端不断展示数据

客户端:

        //创建客户端Socket
        Socket socket = new Socket("127.0.0.1",1111);
        System.out.println("连接成功");
        //键盘录入数据
        System.out.println("请输入数据");
        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){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        socket.close();

服务端:

		//创建服务器端的Socket
        ServerSocket ss = new ServerSocket(1111);
        System.out.println("正在等待连接....");
        while (true){
            //监听客户端连接
            Socket socket = ss.accept();
            System.out.println("连接成功");
            //获取监听客户端所在的通道内的字节输入流
            InputStream in = socket.getInputStream();
            //将字节输入流封装成字符流读
            BufferedReader br = new BufferedReader(new InputStreamReader(in));

            //读
            String line = null;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        }

TCP客户端文件,服务器端将文件复制到指定文件中, 服务器端加入反馈!(图片或者文本文件)

客户端

        //创建客户端的Socket
        Socket s = new Socket("127.0.0.1",2222);
        //创建字符缓冲输入流对象
        //BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("aa.jpg"));
        //获取客户端通道的字节输出流
        //BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
        //读
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
            //刷新
            bos.flush();
        }
        //关闭输出流
        s.shutdownOutput();
        //客户端要读取服务器反馈数据
        //获取通道内的字节输入流
        InputStream inputStream = s.getInputStream();
        //读取
        byte[] bytes1 = new byte[1024];
        int len1 = inputStream.read(bytes1);
        System.out.println("客户端收到了反馈数据"+new String(bytes1,0,len1));

        //释放资源
        s.close();
        bis.close();

服务端:

       //创建服务器端的Socket对象
        ServerSocket ss = new ServerSocket(2222);
        //创建客户监听连接
        Socket s = ss.accept();
        //获取监听客户端所在的通道内字节输入流对象,包装成字符缓冲输入流
        //BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
        //将监听客户端的通道内的字节流的内容,通过的字符缓冲输出流写入到文件中
        //BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
        //读,写
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);

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

二.反射

1.定义

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2.获取类的字节码文件

//三种方法
    	//对象名.getClass
        Persion p = new Persion();
        Class cls1 = p.getClass();
        System.out.println(cls1);

        //类名.Class
        Class cls2 = Persion.class;
        System.out.println(cls2);

        //class.forName("类的全路径");
        Class cls3 = Class.forName("com.reflect.Persion");
        System.out.println(cls3);

3.常用方法

//获取包名、类名
clazz.getPackage().getName()//包名
clazz.getSimpleName()//类名
clazz.getName()//完整类名
 
//获取成员变量定义信息
getFields()//获取所有公开的成员变量,包括继承变量
getDeclaredFields()//获取本类定义的成员变量,包括私有,但不包括继承的变量
getField(变量名)
getDeclaredField(变量名)
 
//获取构造方法定义信息
getConstructor(参数类型列表)//获取公开的构造方法
getConstructors()//获取所有的公开的构造方法
getDeclaredConstructors()//获取所有的构造方法,包括私有
getDeclaredConstructor(int.class,String.class)
 
//获取方法定义信息
getMethods()//获取所有可见的方法,包括继承的方法
getMethod(方法名,参数类型列表)
getDeclaredMethods()//获取本类定义的的方法,包括私有,不包括继承的方法
getDeclaredMethod(方法名,int.class,String.class)
 
//反射新建实例
clazz.newInstance();//执行无参构造创建对象
clazz.newInstance(222,"韦小宝");//执行有参构造创建对象
clazz.getConstructor(int.class,String.class)//获取构造方法
 
//反射调用成员变量
clazz.getDeclaredField(变量名);//获取变量
clazz.setAccessible(true);//使私有成员允许访问
f.set(实例,值);//为指定实例的变量赋值,静态变量,第一参数给null
f.get(实例);//访问指定实例变量的值,静态变量,第一参数给null
 
//反射调用成员方法
Method m = Clazz.getDeclaredMethod(方法名,参数类型列表);
m.setAccessible(true);//使私有方法允许被调用
m.invoke(实例,参数数据);//让指定实例来执行该方法

通过构造方法创建对象

		//方法一:
        Persion p = new Persion();
        System.out.println(p);
        System.out.println("--------------------------");
        //方法二:通过反射获取构造器(Constructor)对象--->创建当前类实例
        //1.获取类字节码文件
        Class cls = Class.forName("com.reflect.Persion");
        //2.获取指定的构造方法所在的Constructor类对象
        Constructor constructor = cls.getConstructor();
        //3.通过它创建当前类实例
        //public T newInstance(Object... initargs):参数就给构造函数中参数进行实际赋值
        Object obj = constructor.newInstance();
        System.out.println(obj);

使用反射方式通过构造方法赋值

 		//1.获取当前类的字节码文件对象
        Class cls = Class.forName("com.reflect.Persion");
        //2.获取构造器Constructor类对象--->带两个参数的
        Constructor constructor = cls.getDeclaredConstructor(String.class, String.class);
        //3.提供功能:取消Java语言访问检查,暴力访问
        //setAccessible(boolean flag) true:就是抑制Java语言访问检查功能
        constructor.setAccessible(true);
        //4.通过它创建当前类实例
        Object obj = constructor.newInstance("高圆圆", "女");
        System.out.println(obj);

使用反射的方式调用成员方法

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

        //2)通过无参构造器创建器Constructor创建当前类实例        
        Constructor con = clazz.getConstructor();
        Object obj = con.newInstance() ;
   		System.out.println(obj);

        //3)获取指定的成员方法所在的Method类对象       
        Method method = clazz.getMethod("show");//方法本身就是空参,获取所有可见的方法,包括继承的方法
        System.out.println(method);        
        method.invoke(obj) ; //本身这个方法没有返回值,单独调用

        System.out.println("----------------------------------------------------------");

        Method m1 = clazz.getDeclaredMethod("method", String.class);//获取本类定义的的方法,包括私有,不包括继承的方法
        //私有方法取消Java语言检查,暴力访问
        m1.setAccessible(true) ;
        m1.invoke(obj,"hello,高圆圆") ;

通过反射获取一个类的成员变量的类的对象Field并去赋值

		//获取字节码文件
        Class cls = Class.forName("com.reflect.Person");
        //创建实例对象
        Object obj = cls.newInstance();
        System.out.println(obj);

        //通过字节码文件对象获取成员变量的Field类对象
        Field namefield = cls.getDeclaredField("name");//获取本类定义的成员变量,包括私有
        namefield.setAccessible(true);
        namefield.set(obj,"张三");
        System.out.println(obj);	

4.反射的应用

ArrayList里添加字符串

        //创建集合
        ArrayList<Integer> arr = new ArrayList<>();
        //添加数据
        arr.add(12);
        arr.add(122);
        arr.add(22);
        arr.add(42);
        arr.add(13);
        System.out.println(arr);

        //获取字节码文件
        Class cls = arr.getClass();
        //获取add方法
        Method addmethod = cls.getMethod("add", Object.class);
        //添加其它类型数据
        addmethod.invoke(arr,"张三");

通过读取.properties文件的方式,

		//读取配置文件
        InputStream ips = ReflectDemo2.class.getClassLoader().getResourceAsStream("classname.properties");
        //创建空集合列表
        Properties properties = new Properties();
        properties.load(ips);
        System.out.println(properties);
        //通过属性列表获取值
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");

        //获取字节码文件对象
        Class cls = Class.forName(className);
        //创建当前实例
        Object obj = cls.newInstance();
        //通过字节码文件获取方法
        Method method = cls.getMethod(methodName);
        System.out.println(method);
        method.invoke(obj);

5.反射—jdk动态代理

结论:使用接口实现方式，运行时，在内存中动态构建出一个类，然后编译，执行。这个类是一次性的，JVM停止，代理类就消失。

三.数据库

1.什么是数据库

数据库就是存储数据的一种仓库
早期存储数据--->临时变量(局部变量)--->随着方法的调用而存在,随着方法调用的结束而消失
后面-------->成员变量(非静态)----->随着方法对象的创建而存在,随着对象的创建完毕等待垃圾回收器回收而消失
容器-------->数组---->长度固定(弊端)
	--->StringBuffer--->字符串缓冲区中存储各种字符序列,它长度可变,但是stringBuffer使用完毕等待回收
	--->集合---->长度可变,它可以存储任意引用类型数据,使用完毕---->也要被回收掉
	--->Io流---->永久存储,但是IO流的太耗时了
数据库存储数据特点--->
	1)存储空间非常大,可以存储百万条,千万条甚至上亿条数据,用户可以对数据库中数据进行新增,查询，更新，删除等操作
	2)数据独立性高
	3)实现数据共享
	4)减少数据的冗余度
	5)通过数据库里面"事务"--->实现数据的一致性以及维护性!

2.市面上常见的数据库

数据库分为两大类:
	关系型数据库:Mysql,SqlServer,Oracle
		SqlServer,Oracle:收费
		Oracle:中大型公司使用居多
		Mysql:免费产品,中小型公司使用居多
	非关系型数据库:Redis,Memcache,MongoDb,Hbase	

3.使用DOS窗口登录启动mysql

使用管理员打开命令提示符:
开启mysql: net start mysql;
关闭mysql: net stop mysql;

4.DDL语句的基础语法

DDL语句:数据库定义语句 库和表的基本操作

库的操作

1.查询所有库:show databases;
2.创建库的语法
	2.1 create database if not exists 库名; 如果没有这个库则创建该库
	2.2 create database 库名;
3.查看指定库的字符集格式
	show create database 库名;
4.修改库的字符集
	alter database 库名 default(可以省略) character set 字符集格式;
5.删除库
	5.1 drop database if exists 库名; 如果有该库则直接删除
	5.2 drop database 库名; 直接删除
6.使用库 
	use 库名;

表的操作

1.创建表的语法
	create table 表名(
		字段名称1 字段类型1,
		字段名称2 字段类型2,
		字段名称3 字段类型3,
		.....
		字段名称n 字段类型n,
	);
2.查询表的结构
	desc 表名;
3.修改表的字段类型
	alter table 表名 modify 字段名称 修改后的字段类型; -- 修改字段类型
	alter table 表名 change 以前的字段名称 修改后的字段名称 字段类型;-- 修改字段名称
4.修改表
	alter table 表名 add 字段名称 字段类型; 添加表的字段
	alter table 表名 drop 字段名称; 删除表中某个字段
	alter table 表名 rename to 新表名; 修改表名
	rename table 表名 to 新表名; 修改表名
5.查看表的字符集
	show create table 表名;
6.修改表的字符集
	alter table 表名 character set 字符集格式;
7.复制表---快速去创建一个结构相同的表
	create table 新表名 like 表名;
	复制表的全数据
	CREATE TABLE 新表名 
	AS 
	SELECT * FROM 表名;
8.删除表
	drop table if exists 表名;如果存在删除表
	drop table 表名;

5.DML语句:数据库操作语句

1.插入数据,没插入的值为null
	插入一行:insert into 表名 values(值1,值2...);
	插入多行:insert into 表名 values(值1,值2...),values(值1,值2...)..;
	插入一行部分字段:insert into 表名(字段名称1,字段名称2.,等部分字段)values(值1,值2,值3...);
	插入多行多条数据,部分字段:insert into 表名(字段名称1,字段名称2.,等部分字段)values(值1,值2,值3...),(值1,值2,值3...),(...);
2.修改数据
	一次修改一个数据: update 表名 set 字段名称= 值 where 字段名称= 值;
	一次修改多个数据: update 表名 set 字段名称= 值1,字段名称= 值2,.. where 字段名称= 值;
3.删除表的记录
	带条件删除
		delete from 表名 where 字段名称 = 值;
    	delete from 表名 where 字段名称1 = 值1 and 字段名称1 = 值1 ...;
    删除全表数据
		方式一:delete from 表名; 只删除 全表数据,表结构还在
		方式二:truncate table 表名; 连表结构删除
4.表的查询
	基本查询:
		1.查询全表:select 全部字段名称 from表名; 使用 select * from 表名;
		查询指定字段并给别名:select id as  '编号',name '姓名' from 表名;
		查询指定字段去重:select distinct 字段 from 表名;
		2.带条件查询
			2.1where 比较运算符 <=,>=,<,>,!=(在mysql使用 <>)
					and  && /or  ||
					between 值1 and  值2
					
		例1:查询年龄是20的学生的编号,姓名,年龄,住址信息
			SELECT id '编号',NAME '姓名',age '年龄',address '住址' FROM student2 WHERE age = 20 ;
		例2:查询年龄在18到20岁之间学生的所有信息
		方式一:SELECT *FROM student2 WHERE age >=18 && age<=20;
		方式二:SELECT * FROM student2 WHERE age >=18 AND age<=20;	
		方式三:SELECT * FROM student2 WHERE age BETWEEN 18 AND 20;
			2.2where 模糊条件 like关键字
				语句格式:select 字段列表 from 表名 where 字段名称 like '%xx%';
				%:表示任意字符
				_:表示一字符
			2.3排序查询 order by,升序是asc,降序是desc
				单独使用语法:select 字段列表 from 表名 order by 字段名称 排序规则;
				与where语句使用时先满足where条件,在排序
				语法:select 字段列表 from 表名 where 条件 order by 字段名称 排序规则,字段名称2 排序规则2;
			2.4聚合函数查询  结果是单行单列,可以sql语句嵌套
				count():统计表的数据,如果字段为空不会统计
				语法:select count(字段名称) from 表名;
				max(列名称):最大值
				语法:select max(列名称) from 表名;
				min(列名称):最小值
				语句:select min(列名称) from 表名;
				avg(列名称):平均值
				语句:select avg(列名称) from 表名;
				sum(列名称);求和
				语句:select sum(列名称) from 表名;
			2.5分组查询:group by 
				语句:select 字段列表 from 表名 group by 分组的字段名称;
				注意:分组查询里面可以select 查询分组字段 
	    			分组group by后面不能使用聚合函数
	    			where条件和group by,where条件在group by前面;先满足where条件在参与分组
			2.6筛选查询:having
				having的后面可以跟聚合函数,having在group by后面,where在group by前面
			2.7分页查询:limit where在limit前面
				方式一;select 字段列表 from 表名 limit 起始行数,每页显示的条数;
				方式二:select 字段列表 from 表名 limit 值;
				复合查询:有where条件,还有limit,where在limit前面
				起始行数= (当前页码数-1)*每页显示的条数;	

6.mysql常见的几种数据类型

int,int(int类型的字符数)
	int:默认11位,
	int(int类型的字符数):int(3):  1---->001
varchar(字符长度):字符串类型
	姓名  varchar(20)---->最大取到20
	在mysql中字符串写的时候可以使用双引号也可以是单引号
date:日期类型--->仅仅表示日期
datetime:日期+时间
timestap:时间戳-->当前插入数据或者修改/删除数据的即时时间
double:小数类型
	double(3,2): 小数是3位数,小数点后保留2位
clob:大字符类型,某个表中某个字段--->使用clob来存储大文本
blob:答字节类型:存储大图片文件---大字节类型

7.约束

约束:约束用户操作数据库的一种行为

默认约束 default

特点:当没有插入这个字段,默认约束起作用
添加默认约束
	创建表时:字段名称 字段类型 default '默认'
	sql语句:alter table 表名 modify 字段名称 字段类型 default '默认';
删除默认约束:修改字段的类型
	alter table 表名 modify 字段名称 修改后的字段类型;

非空约束 not null

特点:当前这个值不能为null,不能直接添加数据给一个null
添加非空约束:
	创建表的时候在指定字段后面加入not null
	sql语句:alter table 表名 modify 字段名称 字段类型 not null;
除非空约束:修改字段的类型
	alter table 表名 modify 字段名称 修改后的字段类型;

唯一约束 unique

特点:当前值不能为空
添加唯一约束:constraint(声明) 
	创建表的时候在指定字段后面加入 unique
	sql语句:alter table 表名 add constraint 唯一约束索引名称 unique(列名);
删除:
	alter table 表名 drop index 索引名(没给就是默认列的名称)

主键约束 primary key

特点:非空且唯一
添加:
	创建表的时候在指定字段后面加入 primary key
	sql语句:alter table 表名 add primary key(列名称);
删除:
	alter table 表名 drop primary key; 

自增长约束 auto_increment

特点:一般自增长约束都是在主键字段上,保证唯一
	指定插入数据的值,下次在之前的值上继续自增1.
ysql自带函数---查找数据库表中最后一次自增主键的值
	select last_insert_id();
添加:
	创建表时添加
注意:指定插入id值时会自增,修改后的值不会自增.

外键约束 foreign key

特点:外键作用的表是从表,另一张表是主表.
添加:
	创建表时添加:
		constraint -- 声明
		外键名 --起名  主表名_从表名_fk
		foreign key(从表的字段名称)
		references -- 关联
		主表名(主键字段的名称)
	sql语句添加:
		alter table 表名 add constraint 外键名 foreign key(从表的字段名称) references 主表名(主键字段名称);
删除:
	有外键时直接修改或者删除主表数据,前提需要让从表的数据跟主表没有关联,才可以删除该表
	sql删除:
		alter table 表名 drop foreign key 外键名

级联操作 cascade

特点:当修改/删除主表的数据,从表数据随之改动
	级联删除/级联修改 on delete cascade /on update cascade
添加:
	创建表示添加:
		constraint -- 声明
		外键名 -- 起名  主表名_从表名_fk
		foreign key(从表的字段名称)
		references -- 关联
		主表名(主键字段的名称)
		on update cascade
		on delete cascade
	sql语句添加:
		alter table 表名 add constraint 外键名 foreign key(从表的字段名称) references 主表名(主键字段名称) on update cascade on delete cascade;

8.数据库表的关系问题—三大范式

表与表之间的关系

表与表的关系	关系的维护
一对多	主外键的关系
多对多	中间表,两个一对多
一对一	特殊一对多,从表中的外键设置为唯一,从表中的主键又是外键

三大范式

什么是范式:
	好的数据库设计对数据的存储性能和后期的程序开发，都会产生重要的影响。建立科学的，规范的数据库就需
要满足一些规则来优化数据的设计和存储，这些规则就称为范式。
第一范式(1NF):
	数据库表的每一列都是不可分割的原子数据项，不能是集合、数组等非原子数据项。即表中的某个列有多个值
时，必须拆分为不同的列。简而言之，第一范式每一列不可再拆分，称为原子性。
第二范式(2NF):
	在满足第一范式的前提下，表中的每一个字段都完全依赖于主键。
	特点:1.一张表只能描述一件事情.
	    2.表中的每一列都完全依赖于主键
第三范式(3NF):
	在满足第二范式的前提下，表中的每一列都直接依赖于主键，而不是通过其它的列来间接依赖于主键。

范式	特点
1NF	原子性
2NF	不产生局部依赖,一张表只描述一件事情
3NF	不产生传递依赖,表中每一列都直接依赖于主键.而不是通过其他列间接依赖于主键

9.多表查询

笛卡尔乘积:
	针对A表的记录和B表的记录数,两个表的记录相乘.
内连接:
	隐式内连接:where条件
		语句格式:select 字段列表 from 表名1,表名2,..表名n where 表之间的连接条件;
	显示内连接:inner join
		语句格式:select 字段列表 from 表名1 inner join 表名2 in 连接条件;
外连接:
	左外连接:将A表(左表)的和B表(右表)的交集以及A表(左表)中所有数据全部查询!
		语句格式:select 字段列表 from 左表名 left join 表名2 on 连接条件;
子查询:select 嵌套 select
	情况1:使用where后面条件表达式=,<=,>=..
	例:查询员工工资最高的员工信息以及他的部门信息
SELECT 
  e.*,
  d.name '部门名称' 
FROM
  employee e,
  dept d 
WHERE e.dept_id = d.id 
  AND e.salary = 
  (SELECT 
    MAX(salary) 
  FROM
    employee) ;
	情况2:利用in集合语句 
	例:查询在"市场部"和销售部的员工信息
SELECT 
  e.*,
  d.name '部门名称' 
FROM
  employee e,
  dept d 
WHERE e.dept_id = d.id 
  AND e.dept_id IN 
  (SELECT 
    id dept 
  WHERE NAME = '市场部' 
    OR NAME '销售部') ;
	情况3:通过两个表的关系--查询出结果集--当做'虚表'在和其他表之间关联查询
	例:查询入职日期大于"2021-11-11"后入职的员工信息以及部门名称信息
SELECT 
  t.name '员工姓名',
  t.join_date '入职日期',
  d.`name` '部门名称' 
FROM
  (SELECT 
    * 
  FROM
    employee e 
  WHERE e.`join_date` > '2021-11-11') t LEFT JOIN 
  dept d 
 ON  t.dept_id = d.id ;

10.数据库的事务/事务的特点/事务的隔离级别

数据库事务

数据库事务(Transaction):在一个业务中执行多个sql(多张表的sql),这多个语句要么同时执行成功,要么同事执行失败.
	举例: 转账操作 一个转账,一个收款
	      提交订单
	          订单表和订单项 同时添加数据
mysql中如何管理事务-- 单独执行这些指令
			start transaction 开启事务
			rollback 回滚到操作sql之前的状态
			commit 事务不提交,数据只是临时提交,数据无法永久更新
-- 查询级别
SELECT @@tx_isolation;
-- 更改级别 
set global transaction isolation level 级别名;			

事务特点

    ACID : 关系型数据库传统事务
    原子性:在使用事务管理的时候,执行多个sql增删改,要么同时执行成功,要么同时执行失败
    一致性:高并发的时候,需要保证事务多次读写,保证数据一致性
    隔离性:事务和事务是独立的,相互不影响
    持久性:事务一旦提交,对数据的影响是永久的,即使关机了,数据还是要更新

事务的隔离级别

四个级别:从大到小,安全性:从低到高,效率性:从高到低
    read uncommitted :读未提交  会造成问题'脏读'
	'脏读':是事务管理最严重的问题,一个事务读取到另一个没有提交的事务
    
    read committed :读已提交 有效防止脏读,出现了一个问题 '不可重复读'
	事务多次读取数据不一致
	
    repeatable read :可重复读(默认),防止脏读,不可重复读,会出现幻读(有更新操作影响)
	
    serializable : 串行话 
	一个事务读取到另一个没提交事务,数据查不到,必须将其提交,才能操作数据

11.JDBC(Java数据库的连接)

七大步骤

public class JdbcDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //jdbc操作:数据库连接
        //1)导入jar包,mysql的驱动jar包3.7版本及以前的jar包连接
        //mysql的驱动jar包如果是8.0以后:url的后面           编码格式         是否启用证书登录     服务器时区         是否公钥模式
        //jdbc:mysql://localhost:3306/ee_2211_02?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
        //2)注册驱动
        Class.forName("com.mysql.jdbc.Driver");

        //3)获取数据库连接对象
        Connection con = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/mydb_02",//localhost：3306/库名
                "root",//mysql的用户名  root用户
                "root" //登录mysql的密码 root
        );

        //4)准备sql语句
        String sql = "INSERT INTO employee VALUES (12,'剑姬','女','1993-08-23',11250,3)";
        //5)通过数据库的连接对象Connection获取数据库的执行对象
        //执行静态sql语句
        Statement sta = con.createStatement();

        //6)执行sql语句
        int count = sta.executeUpdate(sql);
        System.out.println("影响了"+count+"行");

        //7)释放资源
        sta.close();
        con.close();
    }
}