网络编程与反射

一、网络编程

1、UDP

url:统一资源定位符

互联网的三大基石：html、http、url

协议：getProtocol()

域名：getHost()

端口：getPort()

得到锚点：getRef()

        URL url=new URL("https://www.taobao.com");
        System.out.println(url);
        System.out.println("协议"+url.getProtocol());
        System.out.println("端口"+url.getPort());
        System.out.println("域名"+url.getHost());
        System.out.println("查询内容"+url.getQuery());
        System.out.println("锚点"+url.getRef());

2、传输协议

TCP:面向连接，3次握手，安全但开销大，效率低，大小没有限制；

UDP:非面向连接，不安全协议简单，开销小，效率高，只管发只管写，大小限制一般不超过60k;

面向Socket编程：传输层为应用层开辟的口子,用来传出数据

UDP对Socket实现：

DatagramPacket: 打包|数据报包

• DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) 构造一个数据报包发送数据包的长度 length抵消 ioffsetto指定主机上的指定端口号。

• DatagramPacket(byte[] buf, int length) 构造一个 DatagramPacket length接收数据包的长度。

DatagramSocket : 定义发送端或者接收端

• DatagramSocket(int port) 构造一个数据报套接字绑定到本地主机上的指定端口。

• DatagramSocket(int port, InetAddress laddr) 创建数据报套接字,绑定到指定的本地地址。

3、UDP基本流程

发送端：

1. 定义发送端DatagramSocket(int port)

2. 准据数据

3. 打包

4. 发送void send(DatagramPacket p) 从这个套接字发送一个数据报包。

5. 关闭

基本流程：接收端

1. 定义接收端：DatagramSocket(int port)

2. 打包用来接收数据

3. 接收数据： receive(DatagramPacket p) 从这个套接字接收数据报包。

4. 处理数据：byte[] getData() int getLength()

5. 关闭

//发送端
public static void main(String[] args) throws IOException {
        //定义发送端
        DatagramSocket send=new DatagramSocket(1111);
        //准备数据
        byte[] data="hello!!!".getBytes();
        //打包
        DatagramPacket packet = new DatagramPacket(data,0,data.length,new InetSocketAddress("localhost", 6767));
        //发送
        send.send(packet);
        //关闭
        send.close();
    }
//接收端
public static void main(String[] args) throws IOException {
        //定义接送端
        DatagramSocket rec=new DatagramSocket(6767);
        //打包用来接收数据
        byte[] b=new byte[1024*10];
        DatagramPacket packet = new DatagramPacket(b, b.length);
        //接收数据
        rec.receive(packet);
        //处理数据
        byte[] data=packet.getData();
        int len=packet.getLength();
        System.out.println(new String(data,0,len));
        //关闭
        rec.close();
    }

4、TCP基本流程

客户端：

1. 定义客户端:Socket()

2. io操作

3. 关闭

服务端：

1. 定义服务端： ServerSocket(int port) 创建一个服务器套接字绑定到指定端口。

2. 阻塞式监听：accept()

3. io操作

4. 数据的处理

5. 关闭

//客户端
public static void main(String[] args) throws UnknownHostException, IOException {
        TcpSendTest in=new TcpSendTest();
        //定义客户端
        Socket so=new Socket("localhost",6060);
        //IO操作
        OutputStream out=so.getOutputStream();
        System.out.println("请输入用户名：");
        String name=in.input();
        System.out.println("请输入密码：");
        String pwd=in.input();
        String str="name="+name+"&"+"pwd="+pwd;
        out.write(str.getBytes());
        InputStream is = so.getInputStream();
        byte[] b=new byte[1024];
        int len=is.read(b);
        System.out.println(new String(b,0,len));
        is.close();
        //刷出
        out.flush();
        //关闭
        out.close();
        so.close();
    }
    public String input() {
        Scanner scan=new Scanner(System.in);
        String str=scan.next();
        return str;
    }
//服务端
public static void main(String[] args) throws IOException {
        System.out.println("---------服务端---------");
        //定义服务端
        ServerSocket server = new ServerSocket(6060);
        boolean flag=true;
        while(flag) {
            //阻塞监听
            Socket socket = server.accept();
            //io操作
            InputStream in =socket.getInputStream();
            byte[] b=new byte[1024];
            int len=in.read(b);
            //数据处理
            String str=new String(b,0,len);
            String[] s=str.split("&");
            String uname=null;
            String upwd=null;
            for(String i : s) {
//              System.out.println(i);
                String[] n=i.split("=");
//              System.out.println(Arrays.toString(n));
                if(n[0].equals("name")) {
                    uname=n[1];
                }else if(n[0].equals("pwd")) {
                    upwd=n[1];
                }
            }
            OutputStream os = socket.getOutputStream();
            if(uname.equals("cl")&&upwd.equals("123")) {
                os.write("登录成功!".getBytes());
            }else {
                os.write("登录失败!".getBytes());
            }
//          System.out.println(uname+upwd);
//          System.out.println(str);
            os.flush();
            //关闭
            os.close();
            in.close();
            socket.close();
        }
        server.close();
    }

二、反射

反射发生在程序运行期间的行为；

java反射机制，可以实现的功能：

• 在运行时判断任意一个对象所属的类

• 在运行时构造任意一个类的对象

• 在运行是判断任意一个类所具有的成员变量和方法；

• 在运行时调用任意一个对象的方法；

• 生成动态代理

反射的源头：一个类型的class对象

如果能够获取一个类的class对象，可以对它进行任何操作；

获取反射的源头|class对象：

• 对象.getClass()

• 类名.class();

• Class.forName(包名+类名)

public class ReflectTest {
    public static void main(String[] args) {
        ReflectTest rf = new ReflectTest();
        //对象.class
        Class<?> c1 = rf.getClass();
        //类.class
        Class<ReflectTest> c2 = ReflectTest.class;
        //Class.forName()
        Class<?> c3 = null;
        try {
            c3=Class.forName("com.cl.test.RefletTest");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}