网络编程 反射

一、网络编程

1.IP

IP:定位网络上的节点(电脑,手机,服务器,路由器...)  InetAddress
 * 	IP分类:
 * 		ipv4  32位
 * 		ipv6  128位
 * 	特殊的IP:
 * 		非注册ip:供组织内部使用  192.168.0.0~192.168.255.255
 * 		本地ip: 127.0.0.1
 * 	ip->域名:DNS服务器进行转换

2.端口

端口: 区分软件 InetSocketAddress

• 0~65535之间的整数,2个字节

• 自定义端口号推荐使用它8000以上

• 统一协议下端口号不能冲突

• 8000以内的预留端口号

• 80 : http

• 8080 : tomcat

• 3306 : mysql

• 1521 : oracle

3.传输层协议

标准,规范,协议

udp : 非面向连接 协议简单,开销小,不安全 大小有限制

tcp : 基于连接 3次握手 协议复杂,开销大,效率低 安全 大小没有限制

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) 创建数据报套接字,绑定到指定的本地地址。

udp基本流程:发送端

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

2.准据数据

3.打包

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

5.关闭

public class UDPSend02{
	public static void main(String[] args) throws IOException {
		System.out.println("-------------发送端----------------");
		//1.定义发送端DatagramSocket(int port)
		DatagramSocket client=new DatagramSocket(6666);
		//2.准据数据
		byte[] arr="海贼王-->香克斯".getBytes();
		//3.打包
		DatagramPacket packet=new DatagramPacket(arr, 0, arr.length,new InetSocketAddress("localhost",9999));
		//4.发送
		client.send(packet);
		//5.关闭
		client.close();
	}
}

udp基本流程:接收端

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

2.打包用来接收数据

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

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

5.关闭

public class UDPReceive03 {
	public static void main(String[] args) throws IOException {
		System.out.println("-------------接收端----------------");
		//1.定义接收端 DatagramSocket(int port)
		DatagramSocket server=new DatagramSocket(9999);
		//2.打包用来接收数据
		byte[] arr=new byte[1024*60];
		DatagramPacket packet=new DatagramPacket(arr, arr.length);
		//3.接收数据  receive(DatagramPacket p) 从这个套接字接收数据报包。 
		server.receive(packet);
		//4.处理数据
		byte[] data=packet.getData();
		int len=packet.getLength();
		System.out.println(new String(data,0,len));
		System.out.println(data.length);
		System.out.println(len);
		//5.关闭
		server.close();
	}
}

tcp基本流程:客户端

1.定义客户端 Socket Socket(InetAddress address, int port) 创建一个流套接字连接到指定的端口号在指定的IP地址。

2.io操作 InputStream getInputStream() 返回此套接字的输入流。

3.关闭

public class TcpClient04 {
	public static void main(String[] args) throws UnknownHostException, IOException {
		System.out.println("------我是客户端-------");
		//1.定义客户端
		Socket client=new Socket("127.0.0.1",9999);
		//2.IO操作
		OutputStream os=client.getOutputStream();
		os.write("今天是星期六".getBytes());
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
		client.close();
	}
}

tcp基本流程:服务端

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

• 2.阻塞式监听 accept()

• 3.io操作

• 4.数据的处理

• 5.关闭

  public class TcpServer05 {
  	public static void main(String[] args) throws IOException {
  		System.out.println("------我是服务端-------");
  		//1.定义服务端  ServerSocket(int port) 创建一个服务器套接字绑定到指定端口。
  		ServerSocket server=new ServerSocket(9999);
  		//2.阻塞式监听 accept() 
  		Socket socket=server.accept(); 
  		System.out.println("一个客户端连接成功了.....");
  		//3.io操作
  		InputStream is=socket.getInputStream();
  		byte[] arr=new byte[1024];
  		int len=is.read(arr);
  		//4.数据的处理
  		System.out.println(new String(arr,0,len));
  		//5.关闭
  		is.close();
  		socket.close();
  		server.close();
  	}
  }
  
  

4.url

url: 统一资源定位符

• 互联网的三大基石: html http url

• URL 类 :

• https://www.shsxt.com:80/teacher.html

• 协议:String getProtocol()

• 域名: String getHost()

• 端口:int getPort()

• 资源:

  String getPath()
  ​ 得到这个 URL路径的一部分。
  ​ String getHost()
  ​ 这个 URL的主机名,如果适用的话。
  ​ int getPort()
  ​ 这个 URL的端口号。
  ​ String getProtocol()
  ​ 这个 URL的协议名称。
  ​ String getQuery()
  ​ 获取查询 URL的一部分。
  ​ String getRef()
  ​ 得到了锚(也称为“参考”) URL

  public class Demo01 {
  	public static void main(String[] args) throws IOException {
  		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());
  		//获取一个从url位置到程序的输入流
  		InputStream str=url.openStream();
  		//读取
  		byte[] car=new byte[1024];
  		int len=-1;
  		while((len=str.read(car))!=-1){
  			System.out.println(new String(car,0,len));
  		}
  	}
  }
  

二、反射

1.理解

反射发生在程序运行期间的行为 动态机制

Java反射机制，可以实现以下功能：
①在运行时判断任意一个对象所属的类；
②在运行时构造任意一个类的对象；
③在运行时判断任意一个类所具有的成员变量和方法；
④在运行时调用任意一个对象的方法；
⑤生成动态代理。

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

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

如何获取反射的源头|Class对象呢

• 反射的对象独一份的,在反射包下

• 1.对象.getClass()

• 2.类名.class();

• 3.Class.forName(报名+类名)

  Person obj=(Person)Class.forName(o).newInstance();
  		obj.sleep();
  		
  		System.out.println("".getClass());
  		System.out.println(String.class=="".getClass());
  		
  		Class cls=Class.forName("java.lang.String");
  		
  		System.out.println(cls.getName());
  		System.out.println(cls.getSimpleName());
  		System.out.println(cls.getModifiers());
  		System.out.println(Modifier.toString(cls.getModifiers()));
  		System.out.println(int.class.isPrimitive());
  	}
  } 
  
  
  class Person{
  	void sleep(){
  		System.out.println("睡觉");
  	}
  }
  class Student extends Person{
  	void sleep(){
  		System.out.println("边上课边睡觉");
  	}
  }
  class Teacher extends Person{
  	void sleep(){
  		System.out.println("边讲课边睡觉");
  	}
  }
  
  

2.操作构造器|操作方法|操作属性

1)获取构造器

• Constructor getConstructor(Class<?>… parameterTypes)
  Constructor<?>[] getConstructors()
  以上只能获取公共的构造器
  Constructor getDeclaredConstructor(Class<?>… parameterTypes)
  Constructor<?>[] getDeclaredConstructors()
  ​ 以上两个获取所有修饰符修饰的

• 2)指定使用这个构造器在创建对象的时候为对象初始化信息

• 直接通过Class类中的newInstance() 方法创建调用,默认调用空构造

• 通过Constructor的newInstance() 创建对象,执行使用当前构造器对对象初始化信息

  2） 操作方法

  • 获取方法四个

  • 操作方法 Object invoke(Object obj, Object… args) 执行这个方法 第一个参数匹配调用方法的对象,如果是静态方法设置为null 第二个参数:实参

    操作属性**

  • 获取属性四个 getFields()…

  • 操作属性方法: void set(Object obj, Object value) 为某一个属性设置值 第一个参数对象这个成员变量的对象 第二个参数:属性的值

  • get(Object obj) 获取某一个对象的当前属性值

    public static void main(String[] args) throws Exception {
    //		testConstructor(User.class);
    		testField(User.class);
    	}
    
    	//测试反射操作属性(变量)
    	public static void testField(Class<User> cls) throws Exception{
    		//创建一个User对象
    		User user=cls.newInstance();
    		Field field=cls.getDeclaredField("pwd");
    		field.setAccessible(true);
    		field.set(user, 123);
    		System.out.println(user);
    		System.out.println(field.get(user));
    		field.setAccessible(false);
    	}
    	
    	//测试操作构造器
    	public static void testConstructor(Class cls) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{
    		Constructor[] cons=cls.getConstructors();
    		System.out.println(Arrays.toString(cons));
    		//1.创建对象指定使用某个构造器
    		Object obj=cons[1].newInstance();
    		System.out.println(obj);
    		
    		//2.通过使用私有构造器
    		Constructor con=cls.getDeclaredConstructor(String.class);
    		//放开构造器的权限  
    		con.setAccessible(true); //打开权限
    		User user=(User)con.newInstance("zhangsan");
    		con.setAccessible(false); //关闭权限
    		System.out.println(user);
    		
    		//3.直接通过class对象创建对象,默认调用共构造
    		User user2=(User)cls.newInstance();
    		System.out.println(user2);
    	}
    }
    
    class User{
    	private String name;
    	private int pwd;
    	
    	public User() {
    		// TODO Auto-generated constructor stub
    	}
    
    	private User(String name) {
    		this.name = name;
    	}
    	
    	public User(String name, int pwd) {
    		super();
    		this.name = name;
    		this.pwd = pwd;
    	}
    
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", pwd=" + pwd + "]";
    	}
    	
    }