02_框架基础之反射(框架基础)：跟着宝哥学Java：全网最详细

1 框架的概念

写好的程序的半成品：大师根据功能或者某层搭好的软件基础：
                程序员在框架的基础上进行开发
框架： 提高开发效率 降低开发难度    
常见的框架：
  hibernate:持久层(替代jdbc)
  mybatis:持久层(替代jdbc)
  springmvc:控制层(替代servlet)
  struts2:控制层(替代servlet)
  mybatisplus:持久层(替代jdbc)
  spring:中间层(整合其他层和技术)
  springsecurity:权限
  fastdfs：图片服务器
  oss：图片服务器
  sso:点单登录·

2 框架基础

框架底层的技术：
1 反射 reflect
2 注解 annotation
3 xml dom解析
4 代理 proxy
5 io
6 socket
7 序列化：ObjectStream

3 反射

反射：通过类的字节码文件 动态的创建对象和获取类的成员
参照：杀鸡取卵、守株待兔
反射相关的四个类：Class：类的字节码文件对象
               Constructor：类的构造方法对象
               Field：类的成员变量对象
               Method:类的普通方法对象

4 Class类

4.0 准备工作

package com.zhiyou100.demo012_reflect;

public class Student {
	private int sid;
	private String sname;
	private float score;
	private String sex;
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public float getScore() {
		return score;
	}
	public void setScore(float score) {
		this.score = score;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Student(int sid, String sname, float score, String sex) {
		System.out.println("构造方法：public Student(int sid, String sname, float score, String sex)");
		this.sid = sid;
		this.sname = sname;
		this.score = score;
		this.sex = sex;
	}
	public Student() {
		System.out.println("构造方法：public Student()");
	}
	public void hehe(){
		System.out.println("普通方法：：public void hehe()");
	}
	public double haha(int a,float b){
		System.out.println("普通方法：：public double haha(int a,float b)");
		return a+b;
	}
	private void hh(){
		System.out.println("普通方法：：private void hh()");
	}
}

4.1 获取一个类的字节码文件对象的方式

Student student=new Student();
//获取Student类的Class对象的方式
//1:通过Obejct对象的getClasss
Class cla1=student.getClass();
System.out.println(cla1);
//2:通过Student类的class静态属性
Class cla2=Student.class;
System.out.println(cla2);
System.out.println(cla1==cla2);//true:::同一个类只有也给字节码文件对象
//3:通过Class类的静态forName方法
Class cla3=Class.forName("com.zhiyou100.demo012_reflect.Student");
System.out.println(cla3);

4.2 研究Class类中的方法

  /*
   * 类：提取数据作为变量 提取功能作为方法
   * Class类：对类的字节码文件对象的封装
   * 
   * Class类中常用的方法：
   *  1 获取类名：
   *     * String getName()  
   *     * String getSimpleName() 
   *      Package getPackage()   
   *  2 判断类型：
   *      boolean isArray() 
   *      boolean isInterface()  
   *      boolean isEnum()  
   *  3 获取Class对象
   *     * static Class<?> forName(String className) 
   *  4 获取类加载器
   *     * ClassLoader getClassLoader()  
   *  5 获取类的成员
   *      Constructor<?>[] getConstructors()  ：获取所有public修饰的构造方法
   *     * Constructor<?>[] getDeclaredConstructors() ：获取所有的构造方法
   *      Constructor<T> getConstructor(Class<?>... parameterTypes) ：获取public修饰的指定参数的 某个构造方法   
   *     * Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：获取指定参数的 某个构造方法    
   *      Method[] getMethods()  ：获取所有的public修饰的普通方法
   *     * Method[] getDeclaredMethods()  ：获取所有的普通方法
   *      Method getMethod(String name, Class<?>... parameterTypes) ：获取某个public修饰的普通方法
   *     * Method getDeclaredMethod(String name, Class<?>... parameterTypes)：获取某个普通方法
   *      Field[] getFields()  ：获取所有public修饰的成员变量
   *     * Field[] getDeclaredFields()   ：获取所有的成员变量
   *      Field getField(String name)   ：获取指定变量名的public修饰的成员变量
   *     * Field getDeclaredField(String name)  ：获取指定变量名的成员变量
   *  6 创建实例
   *     * T newInstance()   创建实例
   *      
   * */

• 代码

//普通方法
//1 获取类名
System.out.println("获取类名(包名.类名)：getName：："+cla1.getName());
System.out.println("获取类名：getSimpleName：："+cla1.getSimpleName());
//6 创建实例
Student s2=(Student)cla1.newInstance();
System.out.println(s2);
//5获取类的成员
System.out.println("获取所有的public修饰的构造方法对象::getConstructors::"+Arrays.toString(cla1.getConstructors()));
System.out.println("获取所有的构造方法对象::getDeclaredConstructors::"+Arrays.toString(cla1.getDeclaredConstructors()));
System.out.println("获取public修饰的无参数的构造方法::getConstructor::"+cla1.getConstructor(null));
System.out.println("获取public修饰的参数类型为double的构造方法::getConstructor::"+cla1.getConstructor(double.class));
System.out.println("获取任意修饰的参数类型为double的构造方法::getDeclaredConstructor::"+cla1.getDeclaredConstructor(int.class));

System.out.println("获取public修饰的某个成员变量：getField"+cla1.getField("a"));
System.out.println("获取任意修饰的某个成员变量：getDeclaredField"+cla1.getDeclaredField("c"));
System.out.println("获取public修饰的所有成员变量：getField"+Arrays.toString(cla1.getFields()));
System.out.println("获取任意修饰的所有成员变量：getDeclaredField"+Arrays.toString(cla1.getDeclaredFields()));

System.out.println("获取public修饰的某个普通方法：getMethod"+cla1.getMethod("haha", int.class,float.class));
System.out.println("获取任意修饰的某个普通方法：getDeclaredMethod"+cla1.getDeclaredMethod("hh"));
System.out.println("获取public修饰的所有普通方法：getMethods"+Arrays.toString(cla1.getMethods()));
System.out.println("获取任意修饰的所有普通方法：getDeclaredMethods"+Arrays.toString(cla1.getDeclaredMethods()));

5 Constructor类

 /*
		  * 构造器：Constructor
		  * 1: 获取当前构造方法的数据
		  *    String getName()
		  *    int getModifiers()  
		  *    Class<?>[] getParameterTypes()    
		  * 2: 创建对象
		  *     T newInstance(Object... initargs)   
		  * 3: 取消范围修饰符的检查
		  *     void setAccessible(boolean flag)
* */
	     Class cla1=Class.forName("com.zhiyou100.demo012_reflect.Student");
	     Constructor con1=cla1.getDeclaredConstructor(int.class,String.class,float.class,String.class);
	     System.out.println(con1);
	     System.out.println("getName:获取方法名："+con1.getName());
	     System.out.println("getModifiers:获取修饰符："+con1.getModifiers());
	     System.out.println("getParameterTypes:获取参数列表类型："+Arrays.toString(con1.getParameterTypes()));
	     Student s1=(Student)con1.newInstance(1,"eheh",1.1f,"男");
	     System.out.println("s1="+s1);
	     
	     //获取私有的构造方法：private  Student(int sid) 
	     con1=cla1.getDeclaredConstructor(int.class);
	     System.out.println(con1);
	     con1.setAccessible(true);//取消范围修饰符检查
	     s1=(Student)con1.newInstance(1);//IllegalAccessException
	     System.out.println("s1="+s1);

6 Field类

/*字段：Filed
		 *1 获取字段的信息
		 *    String getName()  ：获取属性名
		 *    Class<?> getType()  ：获取属性的类型
		 *    int getModifiers()  ：获取属性的修饰符
		 *2 设置和获取属性的值
		 *    Object get(Object obj) ：获取参数对象的当前属性的值 
		 *    void set(Object obj, Object value) ：设置参数对象obj的当前属性的值为value      
		 * 3 取消范围修饰符的检查
		 *     void setAccessible(boolean flag)
 * */
		Class cla1=Class.forName("com.zhiyou100.demo012_reflect.Student");
		//private String sex;
		Field f1=cla1.getDeclaredField("sex");
		Student s1=new Student(101, "韩梅梅", 11f, "女");
		f1.setAccessible(true);//暴力访问
		//设置s1对象的sex属性的值为 妖
		f1.set(s1, "妖");
		System.out.println("获取s1对象的sex属性的值："+f1.get(s1));//IllegalAccessException:
		System.out.println(s1);
		
		System.out.println("获取属性名："+f1.getName());
		System.out.println("获取属性类型："+f1.getType());
		System.out.println("获取属性修饰符："+f1.getModifiers());

7 Method类

/*普通方法：Method
		 *1 获取方法的信息
		 *  String getName()  ：获取方法名
		 *  int getModifiers()  ：获取方法修饰符
		 *  Class<?> getReturnType()  ：获取方法的返回值类型
		 *  Class<?>[] getParameterTypes()  ：获取方法的参数类型
		 *  Class<?>[] getExceptionTypes() ：获取抛出的异常
		 *2 调用方法
		 *  Object invoke(Object obj, Object... args)     
		 *3 暴力访问
		 *  void setAccessible(boolean flag)  
		 *  
		 * 
 * */
		Class cla1=Class.forName("com.zhiyou100.demo012_reflect.Student");
		//private double haha(int a,float b)
		Method m1=cla1.getDeclaredMethod("haha", int.class,float.class);
		System.out.println("m1==="+m1);
		System.out.println("getName:获取方法名：："+m1.getName());
		System.out.println("getName:获取方法修饰符：："+m1.getModifiers());
		System.out.println("getName:获取方法返回值类型：："+m1.getReturnType());
		System.out.println("getName:获取方法参数列表：："+Arrays.toString(m1.getParameterTypes()));
		System.out.println("getName:获取方法抛出的异常类型：："+Arrays.toString(m1.getExceptionTypes()));
		
		Student s1=new Student(101, "韩梅梅", 11f, "女");
        //调用方法
		m1.setAccessible(true);//暴力访问
		Object result=m1.invoke(s1, 11,22.1f);//IllegalAccessException
		System.out.println("方法返回值值："+result);

总结：

反射其实就是4个类+(4+1+2+1)个方法