第七周学习

最新推荐文章于 2024-07-13 20:38:58 发布
最新推荐文章于 2024-07-13 20:38:58 发布
阅读量677 收藏
点赞数
文章标签： 学习 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53836127/article/details/128163205
版权

tcp和udp

TCP客户端使用步骤

  • 1)创建客户端的Socket对象,指定ip和端口

  • 2)获取客户端通道内容字节输出流对象,写数据

  • 3)释放资源

TCP服务器端的代码实现

  • 1)创建服务器端的Socket对象

  • 2)监听客户端的连接

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

  • 4)释放服务器端的资源

例题

TCP服务器端将复制客户端的文件内容,复制

public class TcpClientTest {
    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){
            bw.write(line) ;
            bw.newLine();
            bw.flush();
        }
        System.out.println("文件读完,发送过去了...");
        //释放资源
        br.close();
        s.close();
​
    }
}
public class TcpServerTest {
    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){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
​
        System.out.println("复制完毕");
        //释放资源
        bw.close();
        ss.close();
​
​
    }
}

问题解决：两个端都出现了互相等待

因为客户端的文本文件读完,是null作为结束条件,但是服务器端不断的从通道内的输入流去读数据,两端的通道不知道文件是否完了(服务器端不知道客户端的文件完没完),等待着写数据过来

解决方案:

通知服务器端,别等了,文件读完了

  • 1)自定义结束条件 ,服务器端读到自定义结束条件,就反馈!

    弊端:如果文件第一句话恰好是自定义的结束条件,就不好

  • 2)推荐:在客户端这边有个终止通道内的流 没有数据写过去了!禁止输出流输出!

    public void shutdownOutput() throws IOException

反射

什么是反射?

  • 编译某个类的时候---->获取这个类的字节码文件,然后去加载,调用里面的成员方法,访问成员变量,通过构造方法创建对象!

编译过程

对这个类的属性/成员/构造其进行校验---->类加载器(负责类的加载过程)

BoostrapClassLoader:启动类加载器,负责java核心库,rt.jar

如何获取一个类的字节码文件?

  • 任意Java对象的getClass方法

    Person p = new Person() ;
Class clazz = p.getClass();
System.out.println(clazz);

  • 任意Java类型的class属性

    Class clazz2 = Person.class ;
System.out.println(clazz2);

  • java.lang.Class:代表正在运行的java类或者接口,通过静态方法

Class clazz3 = Class.forName("com.qf.reflect_06.Person");

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

1)获取类的字节码文件对象

Class clazz = Class.forName("com.qf.reflect_06.Person") ;

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

Constructor con = clazz.getConstructor();

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

Object obj = con.newInstance();
System.out.println(obj);

在反射中如何调用成员方法

1)获取类的字节码文件对象

Class clazz = Class.forName("com.qf.reflect_06.Person") ;

2)通过无参构造器创建器Constructor创建当前类实例

如果你这个类没有提供任何构造方法(系统提供无参)或者无参构造方法是公共的---->此时可以直接使用Class类的newInstacne()创建当前类实例

Object obj = clazz.newInstance();
System.out.println(obj);

3)获取指定的成员方法所在的Method类对象

Method method = clazz.getMethod("show");//方法本身就是空参
System.out.println(method);
method.invoke(obj) ;

4）反射调用

Method m1 = clazz.getDeclaredMethod("method", String.class);
//私有方法取消Java语言检查
m1.setAccessible(true) ;
m1.invoke(obj,"hello,高圆圆") ;
//第一个参数:当前类实例
//第二个参数:给方法的形式参数赋的实际参数
//调用方法到时候将指定的方法实际参数作用在当前类实例上

通过反射调用Person类中的私有的function方法

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        //1)获取当前类的字节码文件对象
        Class clazz =  Class.forName("com.qf.reflect_01.Person") ;
        //2)无参构造方法公共的,直接创建当前类实例
        Object obj = clazz.newInstance();
        //3)通过字节码文件对象获取当前类的成员方法类对象Method
        Method method = clazz.getDeclaredMethod("function");       //System.out.println(method);
        //4)抑制Java语言访问检查
        method.setAccessible(true) ;
        //5)调用方法
        Object returnObj = method.invoke(obj);
     System.out.println(returnObj);
    }
}

通过反射获取这个类的成员变量所在的类对象Field,给成员变量赋值!

public class ReflectDemo2 {
    public static void main(String[] args)  throws Exception{

        //现在要通过反射获取成员变量的Field类对象并且去赋值
        //1)获取当前类的字节码文件对象
        Class clazz = Class.forName("com.qf.reflect_01.Person") ;
        //2)创建当前类实例
        Object obj = clazz.newInstance() ;
        System.out.println(obj) ;
        //3)通过字节码文件对象获取成员变量的Field类对象
        //获取公共的字段(成员变量)Field类对象
        //public Field getField(String name)throws NoSuchFieldException,SecurityException
        //参数是属性名称
        //获取指定的成员变量的Field类对象
        //public Field getDeclaredField(String name)throws NoSuchFieldException,SecurityException

        //private String name ; //私有的成员变量
        Field nameField = clazz.getDeclaredField("name");
        //取消Java语言访问检查
        nameField.setAccessible(true) ;

        //给成员变量的类对象Field赋值
        //public void set(Object obj,Object value)throws IllegalArgumentException,IllegalAccessException
        //就是将指定的成员变量实际参数作用在指定实例上
        //参数1:当前类实例
        //参数2:成员变量的实际参数
        nameField.set(obj,"高圆圆") ;
        System.out.println(obj);
        System.out.println("---------------------------------------------") ;
        //给age赋值
        Field ageField = clazz.getField("age");
        ageField.set(obj,44) ;
        System.out.println(obj) ;
        System.out.println("---------------------------------------------") ;
        //给gender赋值
        Field genderField = clazz.getDeclaredField("gender");
        genderField.setAccessible(true) ;
        genderField.set(obj,"女") ;
        System.out.println(obj);
    }
}

ArrayList<Integer>通过反射给里面加入String类型的数据

public class ReflectTest {
    public static void main(String[] args)  throws Exception{
        //有一个ArrayList集合
        ArrayList<Integer> array = new ArrayList<>() ; //当前类的实例
        //泛型已经明确了数据类型
        array.add(100) ;
        array.add(10) ;
        array.add(25) ;
        array.add(55) ;
        //array.add("helloworld") ;
        System.out.println(array);
        System.out.println("-------------------------------------") ;
        //获取字节码文件对象方式 :三种
        //通过任意Java对象的getClass()获取到了当前正在运行的类字节码文件对象
        Class clazz = array.getClass() ;
        //获取当前它的add方法的Method类对象
        Method m = clazz.getMethod("add", Object.class);
       // System.out.println(m);
        //调用方法
       m.invoke(array,"helloworld") ;
        m.invoke(array,"高圆圆") ;
        System.out.println(array);
    }
}

通过修改配置文件实现不修改代码,而调用另一个类的方法

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        //原来的代码随着需求变化,可能需要用到不同类的某个的功能
        //导致代码改来改去,不灵活
        //设计原则---->"开闭原则" :对修改关闭,对扩展开放!
        // (对现有代码修改不好的,对现有带提供优化,扩展!)

        System.out.println("-------------------------------------------");
        //1)在当期类中读取src下面的xx.properties
        InputStream inputStream = ReflectDemo.class.
                getClassLoader().getResourceAsStream("classname.properties");
        //2)创建一个空的属性集合列表
        Properties prop = new Properties() ;
        //System.out.println(prop);
        //3)加载资源文件输入流的内容到属性集合列表中
        prop.load(inputStream);
        //System.out.println(prop);//{methodName=love, className=com.qf.reflect_02.Student}
        //4)通过属性集合列表中key获取value
        String className = prop.getProperty("className");
        //System.out.println(className);
        String methodName = prop.getProperty("methodName") ;
       // System.out.println(methodName);
        //反射
        //获取当前类的字节码文件对象
        Class clazz = Class.forName(className) ;
        //创建当前类实例 无参构造方法系统提供
        Object obj = clazz.newInstance() ;
        //通过字节码文件对象获取类的成员方法Method类对象
        Method method = clazz.getMethod(methodName);
        //调用方法
        method.invoke(obj) ;
    }
}

代理设计模式

静态代理

代理角色和真实角色需要实现同一个接

动态代理

jdk动态代理

里面需要前提有一个接口

java.lang.reflect.Proxy提供了创建动态代理类和实例的静态方法                    
public static Object newProxyInstance(                                 
ClassLoader loader,        //参数1:当前接口对象的类加载器                                    Class<?>[] interfaces,    //参数2:代理实现接口列表字节码文件对象的数组
InvocationHandler h  //参数3:代理实例 调用处理程序实现的接口
) throws IllegalArgumentException

数据库的事务

在一个业务中执行多个sql（多张表的sql），这个sql语句要么同时执行成功，要么同时执行失败

mysql管理事务

start transaction：开启事务--在操作多个sql语句之前，将整个操作业务管理起来，自动提交切换手动提交事务

执行业务操作：多个sql语句或多张表的增删改，

如果出现问题，可以回滚--rollback

事务特点ACID（关系型数据库传统事务）

原子性，一致性，隔离性，持久性

原子性：在事务管理的时候，执行多个sqk增删改，要么同时成功，要么同时失败

一致性：高并发的时候，需要保证事务多次读写，保证数据一致性

隔离性：事务和事务是独立的，相互不影响

持久性：事务一旦提交，对数据的影响是永久性的，即使关机，数据还是要更改

事务隔离的级别

read uncommitted:读未提交

read committed:读已提交

repeatable read：可重复读

serializable：串行话

  1. 第一种级别read uncommitted:读未提交，会造成“脏读”，脏读是事务管理的最严重的问题：一个事务读取到，另一个没有提交的数据

  2. 第二种级别read committed:读已提交，为了防止脏读，出现一个问题“不可重复读”，事务多次读取的事务不一致

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

  4. 最高级别: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();
​
    }
}
伴我所爱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第七周学习内容
Mr.Sun 的博客
11-29 91
实现一下测试代码功能 //测试代码1：二维坐标点类 Point pPoint = new Point(45, 56); Console.WriteLine(pPoint.X);// 应该输出45 Console.WriteLine(pPoint.Y);//应该输出56 Point pPoint2 = new Point()...
第六周学习
Z______tz的博客
12-06 330
数据库概述 数据的分类 数据即用于描述一些客观事物的符号，这些信息都被成为数据（java中称之为属性） 文本 图形（图片） 图像（视频） 声音 文件 数据库 ​ 由一批数据构成的有序集合，这些数据被分门别类的存放在一些结构化的数据表里（table）里，而数据表之间又往往存在交叉引用关系，这些关系使构成的数据库被成为“关系型数据库” 非关系型数据库：数据存储在磁盘中，类似于缓存机制，表与表之间没有关联 Mysql数据库的好处： 开源免费 轻量级 可制作定制版 数据库的移植 将一种数据库的数据转
第七周学习报告
weixin_74128253的博客
11-18 823
第七周学习报告
Python第七周学习笔记
2302_76661658的博客
12-03 418
第七周学习总结
Aka_bane的博客
04-16 186
本周学习了以下相关内容
Java学习第七周学习总结
10-16
内容包括实用类介绍和输入和输出的处理
第七周学习总结1
08-03
第七周学习总结三种初级排序算法实现：def BubbleSort(self, arr):
520_第七周学习总结1
08-08
七、高级排序算法 在实际工程中，我们常用到的高级排序算法有快速排序、堆排序和归并排序等。这些算法的时间复杂度都是O(nlogn)，空间复杂度也较低。这些算法的优点是时间复杂度较低，但缺点是实现起来较复杂。 八...
《Java程序设计》第7周学习总结.docx
12-27
在《Java程序设计》第7周的学习中，主要聚焦于Java图形用户界面（GUI）的事件处理机制。这一部分的学习是Java编程中的一个重要环节，因为它让应用程序具备了响应用户交互的能力，使得程序更加生动和实用。 1. **...
斯坦福大学机器学习第七周编程作业
03-23
在本篇中，我们将深入探讨斯坦福大学吴恩达教授机器学习课程的第七周编程作业，主题聚焦于支持向量机（SVM）。SVM是一种强大的监督学习算法，广泛应用于分类和回归问题，尤其在小样本和高维空间中表现优异。 首先，...
Lumos学习王佩丰Excel第四讲：排序与选择
Sunshine_XX的博客
07-10 277
自定义排序演示：工资条拆分的演示：如果遇到很长的表，标题只存在于顶端，打印出来观感不好，可以这样做：有些版本的excel复制筛选数据容易把背后隐藏的所有数据都复制上去，这时可选中定位条件的“可见单元格”选项，复制粘贴即可。并排表示且，错排表示或。ctrl+shift+↓+→全选，演示说明：回头学原理，先记住一句话，要想筛选对，条件表头不要对。
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 669
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
jmeter-beanshell学习5-beanshell加减乘除运算
朱文宇的博客
07-08 307
jmeter使用beanshell，jmeter beanshell脚本编写，beanshell进行加减乘除运算
ROS基础学习-ROS运行管理
周陽讀書
07-11 731
ROS运行管理。
昇思MindSpore 25天学习打卡营|day20
最新发布
weixin_42036358的博客
07-13 401
生成式对抗网络(Generative Adversarial Networks，GAN)是一种生成式机器学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。最初，GAN由Ian J. Goodfellow于2014年发明，并在论文生成器的任务是生成看起来像训练图像的“假”图像；判别器需要判断从生成器输出的图像是真实的训练图像还是虚假的图像。GAN通过设计生成模型和判别模型这两个模块，使其互相博弈学习产生了相当好的输出。GAN模型的核心在于提出了通过对抗过程来估计生成模型这一全新框架。
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 593
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
Qt/QML学习-动画元素
QT、QML
07-12 665
Qt/QML学习-动画元素
NPDP含金量高吗？什么人适合学习NPDP？
PMP项目管理的博客
07-09 919
开始报名后先提交报名资料，通过审核后缴纳考试费用，即算报名成功；如果报名成功后被抽中审核了的话，则须提交相关资料进行资格审查，通过审查即可参加考试，未通过审核则会将考试费用退还给您；
昇思25天学习打卡营第19天|ShuffleNet图像分类
randomize0的专栏
07-12 938
在第15-18日的学习内容中，我们陆陆续续学习了计算机视觉相关的模型包括图像语义分割、图像分类、目标检测等内容，这些模型的运算往往都是在大算力设备上运行的，今天学习一种可以在移动设备上运行的图像分类模型-“ShuffleNet”。ShuffleNetV1是旷视科技提出的一种计算高效的CNN模型，和MobileNet, SqueezeNet等一样主要应用在移动端，所以模型的设计目标就是利用有限的计算资源来达到最好的模型精度。
新学期第八小组第七周小组的工作总结PPT.pptx
03-13
"新学期第八小组第七周小组的工作总结PPT.pptx" 这篇PPT主要总结了2023年新学期第八小组在第七周的工作情况，内容包括本周工作概况、工作亮点与不足以及下一步的工作计划。以下是详细的分析： 1. **本周工作概况**...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值