Java学习Day39：小西天恭迎天命人！（spring框架）

spring核心思想：

1.IoC思想是把实例化对象的权力交给spring框架去做，而依赖注入则是IoC思想的具体实现

2.Spring是一款主流的Java EE 轻量级开源框架，目的是用于简化Java企业级引用的开发难度和开发周期

3. Spring指的是Spring Framework，通常我们称之为Spring框架。Spring框架是一个分层的面向切面的Java应用程序的一站式解决框架，它是Spring技术栈的核心和基础，是为了解决企业级引用开发的复杂性而创建的

4.Spring有两个核心模块：IoC和AOP。

​ IOC：Inverse of Control的简写，为 控制反转，指把创建对象交给Spring进行管理。（解耦）

​ AOP：Aspect Oriented Programming 的简写，为 面向对象编程。AOP用来封装多个类的公共行为，将那些与业务无关，却为业务模块共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。另外，AOP还解决一些系统层面上的问题，比如日志、事务、权限等

IOC手写从xml文件读取类信息并创建返回一个类的对象

public class BeanUtils {
    private Map<String, Object> map = new HashMap<>();
    public BeanUtils() throws DocumentException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(BeanUtils.class.getClassLoader().getResourceAsStream("student.xml"));
        Element rootElement = document.getRootElement();
        Iterator<Element> iterator = rootElement.elementIterator();
        while (iterator.hasNext()) {
            Element element = iterator.next();
            String id = element.attributeValue("id");
            String className = element.attributeValue("class");
            Iterator<Element> iterator1 = element.elementIterator();
            Class<?> aClass = Class.forName(className);
            Constructor<?> constructor = aClass.getConstructor();
            Object student = constructor.newInstance();
            while (iterator1.hasNext()) {
                Element everyObjectElement = iterator1.next();
                String shuxing_name = everyObjectElement.attributeValue("name");
                String shuxing_value = everyObjectElement.attributeValue("value");
                Field field = aClass.getDeclaredField(shuxing_name);
                field.setAccessible(true);
                String filename = field.getName();
                Method method = aClass.getMethod("set" + filename.substring(0, 1).toUpperCase() + filename.substring(1), field.getType());

                Object value = null;
                if (field.getType().equals(int.class)) {
                    value = Integer.parseInt(shuxing_value);
                } else if (field.getType().equals(String.class)) {
                    value = shuxing_value;
                }
                method.invoke(student, value);
            }
            map.put(id, student);
        }
    }

    public Object getBean(String name) {
        return map.get(name);
    }
}

public class text {
    @Test
    public void m1()throws Exception{
        //IOC的容器
        BeanUtils beanUtils = new BeanUtils();
        student s = (student) beanUtils.getBean("student");
        System.out.println(s);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans>
  <bean id="student" class="GZD.javaBean.student">
    <property name="id" value="1"></property>
    <property name="name" value="viki"></property>
  </bean>
</beans>

5. Spring Framework的特点
控制反转：IoC

面向切面编程：AOP

容器：Spring IoC是一个容器，因为它包含并管理组件对象的生命周期；

一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方库，而且在Spring旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在Spring Framework 的基础上全部使用Spring来实现

入门案例：

1.引入依赖

<dependencies>
    <!-- spring context依赖
             当引入此依赖后，表示将Spring的基础依赖引入了
         -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.24</version>
    </dependency>

</dependencies>

2.创建架构包

3.创建实体类

4.创建spring配置文件（resourses下的.xml文件）

5.在.xml中用标签完成对象创建

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--完成user对象创建
        id属性：唯一标识
        class属性：要创建的对象所在类的绝对路径
    -->
    <bean id="user" class="cn.tedu.spring.User"></bean>
    
</beans>

6. 创建测试类cn.tedu.spring.TestUser进行测试

 @Test
    public void m(){
        // 1.加载spring配置文件，进行对象创建
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("student.xml");
        // 2.获取spring创建好的对象
        student s1=classPathXmlApplicationContext.getBean("student",student.class);
        System.out.println(s1);
    }

7.BeanFactory

• BeanFactory是 IOC 容器的核心接口，它定义了IOC的基本功能。
  • 特点：在第一次调用getBean()方法时，创建指定对象的实例

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

8.ApplicationContext

• 代表应用上下文对象，可以获得spring中IOC容器的Bean对象。
  • 特点：在spring容器启动时，加载并创建所有对象的实例
  • 常用实现类

    1. ClassPathXmlApplicationContext
    它是从类的根路径下加载配置文件 推荐使用这种。
    2. FileSystemXmlApplicationContext
    它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
    3. AnnotationConfigApplicationContext
    当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
    ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");

    😍常用方法

  • 1. Object getBean(String name);
    根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。
    2. <T> T getBean(Class<T> requiredType);
    根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。
    3. <T> T getBean(String name,Class<T> requiredType);
    根据Bean的id和类型获得Bean实例，解决容器中相同类型Bean有多个情况。

     ApplicationContext app =new ClassPathXmlApplicationContext("student.xml");
            System.out.println(app.getId());
            System.out.println(app.getBean("student"));

    spring配置文件

1.Bean标签基本配置

<bean id="" class=""></bean>
* 用于配置对象交由Spring来创建。
* 基本属性：
id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名
* 默认情况下它调用的是类中的 无参构造函数，如果没有无参构造函数则不能创建成功。

2.Bean标签范围配置

<bean id="" class="" scope=""></bean>

1. 当scope的取值为singleton时 Bean的实例化个数：

1个 Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例 Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了

对象运行：只要容器在，对象一直活着

对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2. 当scope的取值为prototype时 Bean的实例化个数：多个

Bean的实例化时机：当调用getBean()方法时实例化Bean

Bean的生命周期： 对象创建：当使用对象时，创建新的对象实例

对象运行：只要对象在使用中，就一直活着

对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

3.Bean生命周期配置

<bean id="" class="" scope="" init-method="" destroy-method=""></bean>
* init-method：指定类中的初始化方法名称
* destroy-method：指定类中销毁方法名称

4.Bean实例化三种方式

无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败<bean id="userDao" class="com.easthome.dao.impl.UserDaoImpl"/>

工厂静态方法实例化

依赖的jar包中有个A类，A类中有个静态方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class StaticFactoryBean { public static UserDao createUserDao(){ return new UserDaoImpl(); } }

<bean id="userDao" class="com.easthome.factory.StaticFactoryBean" factory-method="createUserDao" />

工厂普通方法实例化

依赖的jar包中有个A类，A类中有个普通方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class DynamicFactoryBean 
{ 
public UserDao createUserDao(){ 
return new UserDaoImpl(); 
}

<bean id="dynamicFactoryBean" class="com.easthome.factory.DynamicFactoryBean"/> 
<bean id="userDao" factory-bean="dynamicFactoryBean" factorymethod="createUserDao"/>