Spring学习总结01--Spring了解，IOC，DI

一，Spring简介

1.1是什么

Spring框架是开源的J2EE应用程序框架，
是针对bean的生命周期进行管理的轻量级容器，
以 IOC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核,
还可以整合世界开源的第三方框架和类库

1.2优势

1）方便解耦，简化开发
通过 Spring 提供的 IoC容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度耦合。
2）方便集成各种优秀框架
Spring对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的支持
在每一层都有对应的解决方案

3）降低 JavaEE API 的使用难度
Spring对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

二，IOC(控制反转)，DI（注入依赖）

对象创建的权利由Spring框架完成.由容器管理对象的生命周期.

1.原来的对象的创建都是由用户自己手动创建,这样的方式耦合性 肯定高. 如果类发生了变化,则代码都得修改.
2. 现在所有的对象都交给Spring容器管理. 用户无需关心对象是如何实例化. 容器负责对象的注入即可. 以后几乎不用修改任何代码. 降低了代码的耦合性

2.1 为何反转，如何理解依赖

2.1

2.1.1 编写Dao接口和实现类

public interface UserDao {
    public void save();
}

public class UserDaoImlp implements UserDao {
    @Override
    public void save() {
        System.out.println("UserDao的save...");
    }
}

2.1.2 创建Spring核心配置文件 并配置UserDaoImpl

在类路径下（resources）创建spring.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">

    <!--
        该配置文件作用是管理对象
        术语: bean  被spring容器管理的对象称之为bean
        属性说明:
                id: 是spring容器中对象的唯一标识符.不能重复
                class: 对象的全路径
    -->
    <bean id="userDao" class="com.jt.demo.UserDaoImlp"></bean>

</beans>

2.1.3测试 使用Spring的API获得Bean实例

 @Test
    public void test2(){
        //创建spring容器. 并且加载指定的配置文件 对象已经交给容器管理
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //从容器中获取对象
        UserDao userDao = (UserDao) context.getBean("userDao");//根据id,需类型转换
        UserDao userDao1 = context.getBean(UserDao.class);//根据类型
        userDao.save();
        userDao1.save();
    }

2.2.1，关于Spring容器

Spring容器的数据结构是Map集合，Map<key,value>
key=“user” value=“通过反射机制实例化的对象”

<bean id="user" class="com.jt.demo.User"></bean>

2.2.2 了解反射(怎么创建对象)

默认情况下，反射是通过无参构造创建对象的
反射机制在框架中使用较多，给定类型的路径就可以获取其中的对象，但是必须要有无参构造，否则程序运行异常

 @Test
    public void test3() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        UserDaoImlp user= (UserDaoImlp) Class.forName("com.jt.demo.UserDaoImlp").newInstance();
        user.save();
    }

2.3 Spring注解开发

2.3.1说明

大约在2015年以前 框架的开发需要大量的xml配置文件。导致项目配置比较臃肿,开发效率略低. 但是项目整合时的 报错概率很高. Spring与时俱进 从3开始逐步演化为注解开发. 到了SpringBoot框架的诞生,标志着进入了全注解时代.

2.3.2注解开发步骤

1）编辑User类

package com.jt.demo;

public class User {
    public void say(){
        System.out.println("使用全注解的方式管理对象");
    }
}

2）编辑配置类

说明: 原始的开发使用xxx.xml文件 用来管理对象, 现在都使用java类的形式当作配置文件则将该java类 称之为配置类.

package com.jt.config;

import com.jt.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration //将当前类标识为配置类
public class SpringConfig {//xml
    /**
     *  1.xml形式
     *      <bean id="user" class="com.jt.demo.User"></bean>
     *  2.注解形式
     *     Map集合的结构 Map<方法名,方法的返回值>
     *     @Bean 将方法的返回值,交给Spring容器管理.
     */
    @Bean
    public User user(){
        return new User(); //相当于xml反射机制创建对象
    }
}

3）编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    //利用注解的方式管理对象
    @Test
    public void testDemo1(){
        //1.利用注解的方式启动spring容器
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //2. 从容器中获取对象
        User user = context.getBean(User.class);
        //3. 对象调用方法
        user.say();
    }
}

三 依赖注入DI

public interface Pet {
    void hello();
}

//实现类1
@Component
public class Dog implements Pet{
    @Override
    public void hello() {
        System.out.println("小狗汪汪汪");
    }
}

//实现类2
@Component
public class Cat implements Pet{

    @Override
    public void hello() {
        System.out.println("小猫喵喵秒");
    }
}

@Component
public class User {
    @Autowired//根源解耦
    @Qualifier("dog")   //一个接口有两个实现类的话，需要指定
//    @Resource(name = "cat") //@Autowired+@Qualifier("cat"),不推荐用，javax拓展包
    private Pet pet;//类型是接口，找其实现类

    public void say(){
        pet.hello();
    }
}