Spring框架（反射机制）

1.Spring家族

官网:https://spring.io，从官网我们可以大概了解到：

Spring能做什么:用以开发web、微服务以及分布式系统等光这三块就已经占了JavaEE开发的九成多。

Spring并不是单一的一个技术，而是一个大家族可以从官网的projects中查看其包含的所有技术。

Spring发展到今天已经形成了一种开发的生态圈,Spring提供了若干个项目每个项目用于完成特定的功能。

Spring已形成了完整的生态圈，也就是说我们可以完全使用Spring技术完成整个项目的构建、设计与开发。
 

2.Spring框架

• SpringFramework是Spring生态圈中最基础的项目，是其他项目的根基。

• Data Access:数据访问

• Data Integration:数据集成

• Web: Web开发

• AOP:面向切面编程

• Aspects:AOP思想实现

• Core Container:核心容器

• Test:单元测试与集成测试

核心层

CoreContainer:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块

AOP层

AOP:面向切面编程，它依赖核心层容器，目的是==在不改变原有代码的前提下对其进行功能增强==
Aspects:AOP是思想Aspects是对AOP思想的具体实现

数据层

DataAccess:数据访问，Spring全家桶中有对数据访问的具体实现技术
Dataintegration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
Transactions事务，Spring中事务管理是SpringAP的一个具体实现，也是后期学习的重点内容

Web层

这一层的内容将在SpringMVC框架具体学习

Test层

Spring主要整合了Junit来完成单元测试和集成测试

什么是反射

1.Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
2.Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

反射的优缺点

1、优点：在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。
2、缺点：反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题

反射的使用

导入jar包

 

 接口

 实现类

BookServiceVip类 

public class BookServiceVip implements BookService {
 
    //属性
    public String name;
    int age;
    private String sex;
    private String address;
    //构造方法
 
    public BookServiceVip() {
    }
 
    public BookServiceVip(String name) {
        this.name = name;
    }
 
    public BookServiceVip(String name, int age, String sex, String address) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }
 
    @Override
    public void save() {
        System.out.println("BookServiceVip.....save");
    }
 
    public void fun() {
        System.out.println("BookServiceVip.....save");
    }
}

Servlet层  BookServlet类

package com.kong.servlet;
 
import com.kong.service.BookService;
import com.kong.service.impl.BookServiceVip;
import org.junit.Test;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
 
public class BookServlet {
    BookService bookService=new BookServiceVip();
 
    /**
     * 更换功能需要修改源代码
     */
    @Test
    public void save() throws ClassNotFoundException {
        System.out.println("BookServlet.......save");
        bookService.save();
        //根据类的全类名通过Class获取类的Class加载器
        Class cla = Class.forName("com.wen.service.impl.BookServiceVip");
        //类的加载器可以获得类中的东西----属性(存储数据)、构造方法(创建对象)、功能方法(完成功能)
        //1.获取类中的属性
        Field[] fields = cla.getFields();//只能获取共有的属性
        for (Field field : fields) {
            System.out.println(field);
        }
 
        System.out.println("---------------");
 
        Field[] fields1 = cla.getDeclaredFields();//可以获取任意修饰符修饰的属性
        for (Field field : fields1) {
            System.out.println(field);
        }
 
        System.out.println("==================");
 
        //2.获取类中的构造方法
        Constructor[] constructors = cla.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
 
        System.out.println("----------");
 
        Constructor[] constructors1 = cla.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }
    }
}

在src下创建info.properties配置文件

key=value
className=com.kong.service.impl.BookServiceVip
methodName=fun

Test01类

package com.kong.servlet;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test01 {
    @Test
    public void save() throws Exception{
        //根据类的全类名通过Class获得类的Class加载器
        Class cla=Class.forName("com.kong.serviet.impl.BookServiceVip");
        //类的加载器可以获得类中的东西？ 属性(储存数据)、构造方法(创建对象)、功能方法(完成功能)
        //1.获取类中的属性
        Field[] fields=cla.getFields();//只能获取共有的属性
        for(Field field : fields){
            System.out.println(field);
        }
        System.out.println("...................");

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

        //2.获取类中的构造方法
        Constructor[] constructors=cla.getConstructors();
        for(Constructor constructor:constructors){
            System.out.println(constructor);
        }
        System.out.println("-----------------------");

        //3.获取类中的功能方法
        Method[] methods = cla.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("--------------");

        Method[] methods1 = cla.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }

    }
}

Test02类

package com.kong.servlet;

import com.kong.serviet.BookService;
import org.junit.Test;

import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.util.Properties;

public class Test02 {
    @Test
    public void test() throws Exception {
        //读取配置文件
        //1.通过文件为止获得输入流
//        File file=new File("D:\\专业课\\spring\\spring01\\src\\info.properties");
//        InputStream stream=new FileInputStream(file);
        //2.在类的根路径 src 加载配置文件
        InputStream stream=Test02.class.getClassLoader().getResourceAsStream("info.properties");
        //使用Properties加载输入流
        Properties p=new Properties();
        p.load(stream);
        //获取配置文件中key值对应的value
        String value = p.getProperty("key");//根据配置文件的key 获取 对应的value值
        String className = p.getProperty("className");

        //根据类的全类名通过Class获得类的Class加载器
        Class cla=Class.forName(className);
        //获取类的构造器
        Constructor constructor = cla.getConstructor();
        //使用构造器创建对象
        BookService bookService= (BookService) constructor.newInstance();
        //执行对象的方法
        bookService.save();
    }
}