Java反射 socket

0905上午

知识点：

1.Thread

2.run

3.start

4.Thread.currentThread().getName()

main

网络编程（不同主机之间的数据传输）

三要素

1.ip 主机的唯一标识

2.端口 主机所运行的程序的唯一标识

65536 0-1023知名端口

1024-49151 用户程序进程

49152-65535 私有动态端口

3.协议

tcp/ip

tcp通讯协议

可靠

请求-响应 服务器

客户端向服务器发送请求

服务器接收请求

服务器向客户端发送响应

客户端接收响应

Socket套接字

利用io流实现数据传输

总结

tcp socket网络信息传输

server

1.ServerSocket

new ServerSocket(port)

2.当有用户访问，创建套接字

Socket s=ss.accept();

3.读取请求 获取InputStream  socket.getInputStream();

int len=is.read(bytes);

new String(bytes,0,len,"utf-8")

4.发送响应OutputStream socket.getOutputStream();

os.write("".getBytes ("utf-8"));

client 客户端

1. Socket s=new Socket("ip或者域名",port);

 如

localhost 本机的域名

127.0.0.1 本机ip

     

2.发送请求

3.接收响应

作业

向教师发送自己靓照

1.发两次

1.发送图片文件

2.发送您的名字

1.现阶段服务器不是1对1，而是为多个客户端提供服务

2.网络编程，多线程

3.步骤

1.ServerScocke ss=new ServerSocket(port)

2.while(true){

Socket s=ss.accept();

3.new ServerThread(s).start;

}

4.编写线程类，传递Socket对象,要实现的功能，就通过run方法调用，或者直接写在run方法中

接收用户发送的文件，并且保存，简单的上传，

解决文件重名 UUID.randomUUID().toString();

tomcat

静态资源，动态页面

iis

nginx

反向代理，并发高 开源软件

静态资源服务器

1. 获取到浏览器的请求头部，并且分析请求

// 客户端获取index.html
int len=0;
byte[]bytes=new byte[1024];
len=socket.getInputStream().read(bytes);
//这行代码是用于读取从 socket 连接中接收到的数据，并将其存储在字节数组 bytes 中。
// socket.getInputStream() 返回与 socket
// 关联的输入流对象，而 read(bytes) 方法会从输入流中读取数据，
// 并返回实际读取的字节数。这个值会被赋给变量 len，用于表示读取的字节数量。
String req=new String(bytes,0,len,"utf-8");
String req1=req.split("\r\n")[0].split(" ")[1];
String pathName=req1;
//从字节数组中创建一个字符串，并且使用utf-8编码。然后，你通过将请求字符串以"\r\n"分割，
// 并取第一个元素再进行空格分割，获取了pathName的值

1. 建立管道  磁盘文件->java内存 fis  java内存=>客户端浏览器

       读取磁盘中的index.html文件，并且通过socket发送给浏览器
            FileInputStream fis=new FileInputStream("webapp" +pathName);

            //将本地读取的文件发送给客户端
            OutputStream os=socket.getOutputStream();

3.发送消息头

 os.write("HTTP /1.1 200 ok\r\n".getBytes("utf-8"));

                os.write("Content-Type:text/html\r\n".getBytes("utf-8"));

                File file=new File("webapp"+pathName);

                os.write(("Content-Length:" + file.length() + "\r\n").getBytes("utf-8"));

                os.write("\r\n".getBytes("utf-8"));

//这个时候还不能直接将数据响应给客户单，服务器和浏览器交互的时候，还需要协议
os.write("HTTP /1.1 200 ok\r\n".getBytes("utf-8"));
os.write("Content-Type:text/html\r\n".getBytes("utf-8"));
File file=new File("webapp"+pathName);
os.write(("Content-Length:" + file.length() + "\r\n")
        .getBytes("utf-8"));

os.write("\r\n".getBytes("utf-8"));

1. 数据响应

while ((len=fis.read(bytes))!=-1){
    os.write(bytes,0,len);

0905下午 完成服务器代码构建和测试，并理解代码意义  生成jar包，同时源码打包提交

使用 java反射

what

在运行状态下，对于任意一个类，知道这个类的属性和方法。

why

解耦 解决耦合问题，类和类之间依赖类关系减少

how

1.类

dirverclass=com.mysql.cj.jdbc.Driver

Class.forName("com.mysql.cj.jdbc.Driver");

2.构造

3.方法

1.获得class对象,class管理指定类的方法，属性和构造方法以及其他的

1.Class c=Class.forName("要调用的类的路径"); com.mysql.cj.jdbc.Driver

2.通过类获得 Student.class;

3.通过一个对象获得 obj.getClass();

2.管理指定类的方法，成员变量，构造方法

getMethods() 返回所有共有的方法

getConstructors() 返回所有的共有构造函数

getFields() 返回所有的共有成员变量

getDeclaredMethods() 返回所有的方法

getDeclaredContructors()

getDeclaredFields()

根据参数和名称指定一个方法

getConstructor(参数类型.....)

getMethod(方法名称,参数类型)

3.Constructor

为什么要获得构造方法：因为构造方法是创建对象

1.使用参数确定构造方法 Constructor ctt0=c.getContructor(null);

Constructor ctt1=c.getConstructor (int.class,String.class,float.class);

2.使用构造方法对象的new Instance()，来构建对象

ctt1.newInstance(1,"张敏",3.89f);

4.Method

1.找到指定的方法

Method m=c.getMethod(方法名,int.class,String.class)

2.使用该方法

String x=m.invoke(obj,param1,param2,,,,,,,);

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class Test001 {
    public static void main(String[] args) {

        try {
            //获得Student类的class对象
            Class c=Class.forName("co.goho.yuanyu.pojo.Student");
            //获得Student类中所有的公开方法，返回一个方法数组
            Method[]methods=c.getMethods();
            for (Method m: methods) {
                System.out.println(m.getName());
            }

            //获得Student类的构造方法
            Constructor [] constructors=c.getConstructors();
            for (Constructor ctt:constructors
            ) {
                System.out.println(ctt.getName());
            }

            //获得Student类中的成员变量
            Field[]fields=c.getFields();
            for (Field field:
                    fields) {
                System.out.println(field.getName());
            }

            Field[]fields1=c.getDeclaredFields();
            for (Field field:fields1
            ) {
                System.out.println(field.getName());
            }

            //根据方法名称和参数类型，找到特定的方法
            Constructor noArgsCOnst= c.getConstructor(null);
            System.out.println(noArgsCOnst.getParameterCount());

//            使用class对象获得构造方法，并且使用构造方法创建对象
            Constructor ctt0=c.getConstructor(null);
            Object o0=ctt0.newInstance();
            System.out.println(o0);

            //调用有参构造
            Constructor ctt2=c.getConstructor(int.class,String.class,float.class);
            Object o1=ctt2.newInstance(1,"张三",3.8f);
            System.out.println(o1);


            //o0对象只有初始化属性，显示 3,"李四" 200
            //找到对象的三个set
            Method a=c.getMethod("setId",int.class);
            Method b=c.getMethod("setName",String.class);
            Method d=c.getMethod("setBalance",float.class);

            a.invoke(o0,3);
            b.invoke(o0,"李四");
            d.invoke(o0,200f);
            System.out.println(o0);

        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }

        Map<String,Object>map=new HashMap<String,Object>();
        map.put("id",4);
        map.put("name","王五");
        map.put("balance",3.89);

//        Student s=getBean(Student.class,map);
    }

}