java反射、Spring框架 IOC/DI
目录
1、反射介绍
2、 常用方法
3、反射的应用
3.1 测试物料类
3.2 获取类对象
3.3 获取成员变量
3.4 通过字节码对象获取类的成员方法
3.5 通过字节码对象获取类的构造方法
4、创建对象
5、Spring框架 IOC/DI
5.1 IOC (inversion of Control) 控制反转
5.2 DI(DependencyInjection)依赖注入
接口区别
1、反射介绍
Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，但反射能直接操作类私有属性。反射可以在运行时获取一个类的所有信息，（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法。所以先要获取到每一个字节码文件对应的Class类型的对象。
反射就是把java类中的各种成分映射成一个个的Java对象。
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把一个个组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
加载的时候：Class对象的由来是将 .class 文件读入内存，并为之创建一个Class对象。
2、 常用方法
当我们获得了想要操作的类的Class对象后，可以通过Class类中的方法获取和查看该类中的方法和属性。
//获取包名、类名
clazz.getPackage().getName()//包名
clazz.getSimpleName()//类名
clazz.getName()//完整类名
//获取成员变量定义信息
getFields()//获取所有公开的成员变量,包括继承变量
getDeclaredFields()//获取本类定义的成员变量,包括私有,但不包括继承的变量
getField(变量名)
getDeclaredField(变量名)
//获取构造方法定义信息
getConstructor(参数类型列表)//获取公开的构造方法
getConstructors()//获取所有的公开的构造方法
getDeclaredConstructors()//获取所有的构造方法,包括私有
getDeclaredConstructor(int.class,String.class)
//获取方法定义信息
getMethods()//获取所有可见的方法,包括继承的方法
getMethod(方法名,参数类型列表)
getDeclaredMethods()//获取本类定义的的方法,包括私有,不包括继承的方法
getDeclaredMethod(方法名,int.class,String.class)
//反射新建实例
clazz.newInstance();//执行无参构造创建对象
clazz.newInstance(222,"韦小宝");//执行有参构造创建对象
clazz.getConstructor(int.class,String.class)//获取构造方法
//反射调用成员变量
clazz.getDeclaredField(变量名);//获取变量
clazz.setAccessible(true);//使私有成员允许访问
f.set(实例,值);//为指定实例的变量赋值,静态变量,第一参数给null
f.get(实例);//访问指定实例变量的值,静态变量,第一参数给null
//反射调用成员方法
Method m = Clazz.getDeclaredMethod(方法名,参数类型列表);
m.setAccessible(true);//使私有方法允许被调用
m.invoke(实例,参数数据);//让指定实例来执行该方法3、反射的应用
3.1 测试物料类
创建包: com.reflection
创建类: Student.java*
package com.review;
/*本类用于复习反射的物料类*/
public class Student {
//1.定义成员变量
private String name;
public int age;
//2.给被封装属性提供get与set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//3.生成本类的无参构造与全参构造
public Student(){}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//4.提供本类的普通方法
public void play(){
System.out.println("不玩游戏，学Java！");
}
public void sunDay(int n){
System.out.println("卷起来，没有假！");
}
//5.为了查看学生对象的具体属性与属性值，重写toString()
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}3.2 获取类对象
由于经常使用的是第三种方法，所以以下使用第三种。
创建包: com.reflection
创建类: TestReflect.java
/*本类用于反射的测试*/
public class TestReflect {
//1.可以创建程序的入口函数main()--此处不用
//2.通过单元测试方法，获取目标类Student对应的字节码对象
@Test
public void getClazz() throws ClassNotFoundException {
//练习获取字节码对象的3种方式
Class clazz1 = Class.forName("com.review.Student");
Class clazz2 = Student.class;
Class clazz3 = new Student().getClass();
//打印的是Student类对应的字节码对象
System.out.println(clazz1);//class com.reflection.Student
//获取Student类对应的字节码对象clazz1的名字
System.out.println(clazz1.getName());//com.reflection.Student
//通过Student类对应的字节码对象，获取Student类的类名
System.out.println(clazz1.getSimpleName());
//通过Student类对应的字节码对象，获取Student类对应的包对象
System.out.println(clazz1.getPackage());
//通过Student类对应的字节码对象，先获取Student类对应的包对象，再获取这个包对象的名字
System.out.println(clazz1.getPackage().getName());
}
}3.3 获取成员变量
/**本类用来测试反射*/
public class TestReflect {
//3.通过单元测试方法练习引用类型数组的定义与遍历
@Test
public void getStu() {
//1.创建Student类的3个对象
Student s1 = new Student("张三", 3);
Student s2 = new Student("李四", 4);
Student s3 = new Student("王五", 5);
//2.创建数组将刚刚的3个对象存入数组中
Student[] s = {s1, s2, s3};
//3.直接打印数组，查看数组中的元素
System.out.println(Arrays.toString(s));
//4.遍历学生数组，拿到每一个学生对象，做进一步的操作
for (Student stu : s) {
//System.out.println(stu);
stu.play();//通过遍历到的对象，执行play()
System.out.println(stu.age);//通过遍历到的对象，打印age属性
}
}
//4.通过单元测试方法，获取Student类中的成员变量
@Test
public void getFie() throws ClassNotFoundException {
//1.获取Student类对应的字节码对象
Class clazz = Class.forName("com.review.Student");
//2.通过Student类对应的字节码对象获取Student类中的成员变量们
Field[] fs = clazz.getFields();
//3.遍历数组，获取Student类中的每个成员变量的具体信息
/*注意！目前成员变量的修饰符必须是public的才能获取到*/
for(Field f : fs){
System.out.println(f.getName());//通过本轮循环到的字段对象获取字段名
System.out.println(f.getType());//通过本轮循环到的字段对象获取字段的类型
}
}
}3.4 通过字节码对象获取类的成员方法
/**本类用来测试反射*/
public class TestReflect {
//5.通过单元测试方法，获取Student类中的成员方法
@Test
public void getFunction() {
//1.获取Student类对应的字节码对象
Class clazz = Class.forName("com.review.Student");
//2.通过Student类对应的字节码对象获取Student类中的成员方法们
Method[] ms = clazz.getMethods();
//3.通过高效for循环遍历数组，拿到每一个方法对象
for (Method m : ms) {
System.out.println(m);//直接打印遍历到的方法对象
System.out.println(m.getName());//通过方法对象获取方法名
Class[] pt = m.getParameterTypes();//通过方法对象获取方法所有参数的数组
System.out.println(Arrays.toString(pt));//打印方法参数的数组
}
}
}3.5 通过字节码对象获取类的构造方法
/**本类用来测试反射*/
public class TestReflect {
//6.通过单元测试方法，获取Student类中的构造方法
@Test
public void getCons() {
//1.获取字节码对象
Class clazz = Class.forName("com.review.Student");
//2.通过字节码对象获取目标类Student的构造方法们
Constructor[] cs = clazz.getConstructors();
//3.通过高效for循环遍历数组
for(Constructor c : cs){
System.out.println(c.getName());//打印本轮遍历到的构造方法的名字
Class[] pt = c.getParameterTypes();//通过本轮遍历到的构造函数对象获取构造函数的参数类型
System.out.println(Arrays.toString(pt));//打印参数类型
}
}
}4、创建对象
/**本类用来测试反射*/
public class TestReflect {
//7.通过单元测试方法，创建Student目标类的对象
@Test
public void getObject() throws Exception {
//1.获取字节码对象
Class clazz = Class.forName("com.review.Student");
//2.通过反射技术创建目标类的对象,注意抛出异常
/*反射创建对象方案1：
使用 目标类 的 无参构造 创建对象
*/
Object o = clazz.newInstance();
System.out.println(o);//这一步已经获取到了对象Student{name='null', age=0}
/*反射创建对象方案2：
使用 目标类 的 全参构造 创建对象
* 思路：
* 1.先获取指定的构造函数对象,注意需要指定构造函数的参数，传入的是.class字节码对象
* 2.通过刚刚获取到的构造函数对象创建Student目标类的对象，并且给对象的属性赋值
* */
//3.获取目标类中指定的全参构造
Constructor c = clazz.getConstructor(String.class, int.class);
//System.out.println(c);
//4.通过获取到的构造函数：创建对象 + 给对象的属性赋值
Object o2 = c.newInstance("赵六", 6);
System.out.println(o2);
}
}5、Spring框架 IOC/DI
5.1 IOC (inversion of Control) 控制反转
IOC:控制反转，以前对象需要自己new进行创建，现在把对象创建的操作交给了spring框架，用的时候直接找框架要即可，spring负责所有的对象的创建和管理，称之为IOC容器。
IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象
被创建或被管理的对象在IOC容器中统称为==Bean==
IOC容器中放的就是一个个的Bean对象
不行，因为service运行需要依赖dao对象
IOC容器中虽然有service和dao对象
但是service对象和dao对象没有任何关系
需要把dao对象交给service也就是说要绑定service和dao对象之间的关系
像这种在容器中建立对象与对象之间的绑定关系就要用到DI
5.2 DI(DependencyInjection)依赖注入
在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。业务层要用数据层的类对象，以前是自己new的现在自己不new了，靠别人[外部其实指的就是IOC容器]来给注入进来这种思想就是依赖注入
这个需要程序员根据业务需求提前建立好关系，如业务层需要依赖数据层，service就要和dao建立依赖关系介绍完Spring的IOC和DI的概念后，我们会发现这两个概念的最终目标就是:==充分解耦==，具体实现靠:
使用IOC容器管理bean(IOC)
在IOC容器内将有依赖关系的bean进行关系绑定(DI)
最终结果为:使用对象时不仅可以直接从OC容器中获取，并目获取到的bean已经绑定了所有的依赖关系
一个重要特征是反射，它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入
注入方式: 1.set方式注入 2.构造方法注入 3.字段注入
注入类型: 1.值类型注入 2.引用类型注入
接口区别
BeanFactory，Spring内部使用接口，不提供给开发人员，加载配置xml解析不会创建，只有创建对象才会getBean
ApplicationContext是BeanFactory子接口，功能强大，开发人员可使用，加载配置就会创建对象
ApplicationContext有一些特别的实现类
ClassPathXmlApplicationContext，在src目录下可以写文件名
FileSystemXmlApplicationContext，在src目录下，必须写绝对路径