SpringIOC入门

Posted 2023-04-04 掉了颗大白兔~

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringIOC入门相关的知识，希望对你有一定的参考价值。

2.Spring OC：

什么是SpringIoC?

控制反转ioc(inverse of controll ) 所谓控制反转就是把创建对象(bean),和维护对象(bean)的关系的权利从程序中转移到spring的容器(applicationContext.xml),而程序本身不再维护。之前开发中，直接new一个对象即可。学习spring之后需要实例对象时，从spring工厂（容器）中获得。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

主要内容：

SpringIoC的过程？

基础包扫描。读取配置文件，然后根据配置路径进行全包扫描，，最后将扫描到的类名加上全限定名之后加入到数组集合中

实例化所有带注解的类。遍历上一步的数组集合，判断类上的注解并实例化该类，以该类的类名为key，实例为value，放入哈希表中

依赖注入。遍历上一步的哈希表，获取类上所有Fields，遍历Fields，判断Fields上是否为@Autowired类型的注解，如果是的话就把Map中的实例赋值这个field

Url地址和方法映射。遍历第二步的哈希表，如果是Controller实例，获取Methods并遍历，判断方法上是否含有@RequestMapping注解，如果含有，则获取它的值，将@Controller的注解值拼接上@RequestMapping值组成key，当前method作为value，装入hanlerMap中

请求反射调用。(这一步已经属于MVC范畴)一个url请求过来，获取它的地址，拆分，获取Controller实例，获取Method实例，反射执行Method

为什么要用SpringMVC?

框架的作用一直都是用来简化编程的：
servlet只有doGet和doPost，一个servlet类只能处理一个url-pattern。
SpringMVC类里面可以通过RequestMapping处理很多请求，并且支持Rest风格的请求，如DELETE/PUT等；SpringMVC参数的映射可以直接封装成实体类。

SpringMVC的流程

流程图说明:

用户发送请求至前端控制器DispatcherServlet。
前端控制器DispatcherServlet收到请求后调用处理器映射器HandlerMapping。
处理器映射器HandlerMapping根据请求的Url找到具体的处理器，生成处理器对象Handler及处理器拦截器HandlerIntercepter（如果有则生成）一并返回给前端控制器DispatcherServlet。
前端控制器DispatcherServlet通过处理器适配器HandlerAdapter调用处理器Controller。
执行处理器（Controller，也叫后端控制器）
处理器Controller执行完后返回ModelAndView。
处理器映射器HandlerAdapter将处理器Controller执行返回的结果ModelAndView返回给前端控制器DispatcherServlet。
前端控制器DispatcherServlet将ModelAnView传给视图解析器ViewResolver。
视图解析器ViewResolver解析后返回具体的视图View。
前端控制器DispatcherServlet对视图View进行渲染视图（即：将模型数据填充至视图中）
前端控制器DispatcherServlet响应用户。

使用SpringIOC的步骤是什么？

添加Spring Jar包
创建Spring的配置文件
在配置文件中创建组件
增加组件依赖

案例：

jar包

配置文件：

<?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">
    <!--把所有对象创建到spring的IOC容器中，并起上名字
    id：表示给对象起名字
    class：类的全类名
    -->
    <bean id="bookDao" class="com.su.dao.impl.BookDaoImpl"></bean>
    <bean id="bookService" class="com.su.service.impl.BookServiceImpl">
        <!--spring的依赖注入：property表示BookServiceImpl的属性，常规属性使用value赋值，
        类型属性使用ref引用-->
        <property name="name" value="张三"/>
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

接口：

package com.su.dao;

public interface BookDao 
    public void insert();

实现类：

package com.su.dao.impl;

import com.su.dao.BookDao;

public class BookDaoImpl implements BookDao 

    @Override
    public void insert() 
        System.out.println("BookDaoImpl...insert");

测试：

package com.su.test;

import com.su.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test02 
    @Test
    public void test02()
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        BookService factory= (BookService) context.getBean("BookService");
        System.out.println(factory);

2、依赖注入（DI）

依赖：一个对象需要使用另一个对象

注入：通过setter方法进行另一个对象实例设置。

创建BookService接口和实现类，创建BookDao接口和实现类，将dao和service配置 xml文件

例如：

dao的接口和实现类为：

public interface BookDao 
  public void insert();



public class BookDaoImpl implements BookDao 

    @Override
    public void insert() 
        System.out.println("BookDaoImpl...save");

service接口和实现类为：


public interface BookService 
   void save();
   public class BookServiceImpl implements  BookService

       private BookDao bookDao;
       @Override
       public void save() 
           System.out.println("BookServiceImpl...save");
           bookDao.insert();

package com.su.service.impl;

import com.su.dao.BookDao;
import com.su.service.BookService;

public class BookServiceImpl implements BookService 
    private BookDao bookDao;
    private  String name;

    public void setBookDao(BookDao bookDao) 
        this.bookDao = bookDao;
    

    public void setName(String name) 
        this.name = name;
    

    @Override
    public void save() 
        System.out.println("BookServiceImpl...save");
        bookDao.insert();

配置文件：

<?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">
    <!--把所有对象创建到spring的IOC容器中，并起上名字
    id：表示给对象起名字
    class：类的全类名
    -->
    <bean id="bookDao" class="com.su.dao.impl.BookDaoImpl"></bean>
    <bean id="bookService" class="com.su.service.impl.BookServiceImpl">
        <!--spring的依赖注入：property表示BookServiceImpl的属性，常规属性使用value赋值，
        类型属性使用ref引用-->
        <property name="name" value="张三"/>
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

测试：

package com.su.servlet;

import com.su.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BookServlet 
    BookService bookService;
    @Test
    public void add() 
        System.out.println("BookServlet...add");
//1.获得IOC容器
        ClassPathXmlApplicationContext context=new
                ClassPathXmlApplicationContext("spring.xml");
//2.根据名字从容器中获取对象
        bookService= (BookService) context.getBean("bookService");
        bookService.save();

Spring入门之五-------SpringIoC之通过注解实现

一、准备工作

创建一个Class注解@Configuration，如下例子：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

}

我们创建了一个Class（类名可随意）并注解了@Configuration，这样可以将该Class看做一个spring的xml文件。同时我们增加了@ComponentScan注解开启了包扫描，在扫描包及其子包下面的所有被注解了@Component、@Controller、@Service、@Repository的Class会自动被实例化。

测试代码类似之前通过加载xml格式文件：

@Test
public void testBean() throws Exception {
    final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
    // 省略其他代码...
}

二、通过构造方法实例化Bean

直接在Class上面注解@Component即可，当然也可以注解@Controller、@Service、@Repository。@Component为通用型注解，@Controller、@Service、@Repository则各具有一定的业务含义，一般的@Controller被标注在Controller层、@Service被标注在Service层、@Repository被标注在Dao层。

@Component // 通过构造方法实例化bean
public class Bean1 {
}

@Component // 通过构造方法实例化bean
public class Bean2 {
    private final Bean1 bean1;
    @Autowired // 自动注入Bean1的实例
    public Bean2(Bean1 bean1) {
        this.bean1 = bean1;
    }
}

在上面的两个例子中，Bean1有默认构造方法，则Spring会通过默认构造方法实例化Bean1；Bean2的构造方法包含参数Bean1，所以Spring在实例化Bean2的时候回在IoC容器中寻找Class为Bean1的实例并注入到该构造方法中以完成对Bean2的实例化。其中：@Autowired表示自动注入。

三、注入Bean

1. 通过方法注入Bean

（1）可通过构造方法注入Bean，如上面Bean2的例子

（2）可通过Set方法注入Bean，例如：

@Component // 通过构造方法实例化bean
public class Bean2 {  
    private Bean1 bean1;
    @Autowired // 自动注入Bean1的实例
    public void setBean1(Bean1 bean1) {
        this.bean1 = bean1;
    }
    // get方法省略......   
}

2. 通过属性注入Bean

@Component // 通过构造方法实例化bean
public class Bean2 {  
    @Autowired // 自动注入Bean1的实例
    private Bean1 bean1;
    // get/set方法省略......   
}

3. 集合类型Bean的注入

（1）直接注入集合实例

@Component // 通过构造方法实例化bean
public class Bean {
    private List<String> stringList;
    private Map<String, String> stringMap;

    public List<String> getStringList() {
        return stringList;
    }

    @Autowired // 通过set方法注入bean
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    public Map<String, String> getStringMap() {
        return stringMap;
    }

    @Autowired // 通过set方法注入bean
    public void setStringMap(Map<String, String> stringMap) {
        this.stringMap = stringMap;
    }
}

当然，同时也需要在IoC容器中存在List的Bean和Map的Bean，那么我们怎么实例化这两个Bean呢？修改最开始我们创建的BeanConfiguration即可：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

    @Bean() // 实例化一个List
    public List<String> stringList() {
        List<String> list = new ArrayList<String>();
        list.add("aaaaa");
        list.add("bbbbb");
        return list;
    }

    @Bean() // 实例化一个Map
    public Map<String, String> stringMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("aaa", "111");
        map.put("bbb", "222");
        return map;
    }
}

通常情况下，@Bean用来实例化那些我们不能修改源码的Class，或者需要多次实例化的Class。而@Component系列的四个注解用来实例化我们自己创建的且只需要一次实例化的Class。

那么小伙伴会问了，在上面的例子中，如果我们实例化了多个List或多个Map，Spring在为Bean注入的时候会给我注入哪个呢？答案是：Spring会报错给你看！解决办法就是在通过@Bean和@Component系列实例化Bean的时候指定BeanId，通过@Autowired注入Bean的时候同时通过@Qualifier指定要注入的BeanId。那么上面的例子可以改成：

@Component // 通过构造方法实例化bean
public class Bean {
    // ... 省略部分代码
    @Autowired // 通过set方法注入bean
    @Qualifier("stringList") // 指定注入id为stringList的bean
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }
    // ... 省略部分代码
    @Autowired // 通过set方法注入bean
    @Qualifier("stringMap") // 指定注入id为mapString的bean
    public void setStringMap(Map<String, String> stringMap) {
        this.stringMap = stringMap;
    }
}

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

    @Bean("stringList") // 实例化一个List，id为stringList
    public List<String> stringList() {
         // ... 省略部分代码
    }

    @Bean("stringMap") // 实例化一个Map，id为stringMap
    public Map<String, String> stringMap() {
        // ... 省略部分代码
    }
}

（2）将多个泛型的实例注入到集合

Spring支持将多个泛型的实例注入到集合，举例如下：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

    @Bean("integer1") // 实例化一个Integer，id为integer1
    public Integer integer1() {
        return 10001;
    }

    @Bean("integer2") // 实例化一个Integer，id为integer2
    public Integer integer2() {
        return 10002;
    }
}

在上面的代码中，我们实例化了两个Integer类型数据，并为每个实例设定了beanId。然后：

@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public class Bean {
    private List<Integer> integerList;
    private Map<String, Integer> integerMap;

    public List<Integer> getIntegerList() {
        return integerList;
    }

    @Autowired // 通过set方法注入bean，将注入所有已经交由IoC容器管理的Integer类型的bean
    public void setIntegerList(List<Integer> integerList) {
        this.integerList = integerList;
    }

    public Map<String, Integer> getIntegerMap() {
        return integerMap;
    }

    @Autowired // 通过set方法注入bean，将注入所有已经交由IoC容器管理的Integer类型的bean，其中beanId即为键值
    public void setIntegerMap(Map<String, Integer> integerMap) {
        this.integerMap = integerMap;
    }
}

上面两个@Autowired会将我们在BeanConfiguration中创建的两个Integer类型的Bean全部注入到集合当中，当注入到Map类型（键为String类型）时，beanId即作为键值注入。

测试代码：

@Test
public void testBean() throws Exception {
    final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);   
    System.out.println("bean.getIntegerList() = " + bean.getIntegerList());
    System.out.println("bean.getIntegerMap() = " + bean.getIntegerMap());       
}

输出：

bean.getIntegerList() = [10001, 10002]
bean.getIntegerMap() = {integer1=10001, integer2=10002}

当然，如果你想控制泛型实例在List中的顺序，可以通过增加@Order注解的方式实现：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation")
public class BeanConfiguration {

    @Bean("integer1") // 实例化一个Integer，id为integer1
    @Order(5) // 该注解可决定这个bean被注入到list时候的顺序，可以不连续
    public Integer integer1() {
        return 10001;
    }

    @Bean("integer2") // 实例化一个Integer，id为integer2
    @Order(2) // 该注解可决定这个bean被注入到list时候的顺序，可以不连续
    public Integer integer2() {
        return 10002;
    }
}

则输出结果即变为：

bean.getIntegerList() = [10002, 10001]
bean.getIntegerMap() = {integer1=10001, integer2=10002}

4. String、Integer等类型直接赋值

String、Integer等类型直接赋值可用@Value实现，例如：

@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public class Bean {
    private String string;
    
    public String getString() {
        return string;
    }

    @Value("zzzzz") // 直接将zzzzz这个值注入进去
    public void setString(String string) {
        this.string = string;
    }
}

四、设定Bean的作用域scope

可直接通过@Scope来实现，例如：

@Component // 通过构造方法实例化bean
@Scope("singleton") // 设定bean作用域
public class Bean1 {
}

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation")
public class BeanConfiguration {
    @Bean // 实例化一个Bean1
    @Scope("singleton")  // 设定bean作用域
    public Bean1 bean1() {
        return new Bean1();
    } 
}

五、Bean的懒加载

可直接通过@Lazy实现，例如：

@Component // 通过构造方法实例化bean
@Lazy // 开启懒加载
public class Bean1 {
}

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@Lazy // 开启懒加载
public class BeanConfiguration {
    @Bean // 实例化一个Bean1
    @Scope("singleton")  // 设定bean作用域
    public Bean1 bean1() {
        return new Bean1();
    } 
}

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@Lazy // 开启懒加载
public class BeanConfiguration {
}

注意第三段代码中的@Lazy注解，这意味着在该Configuration中实例化的Bean都将默认为懒加载模式

六、Bean别名

Spring允许一个Bean拥有多个BeanId，但暂时只能在@Bean中实现，@Component系列四个注解暂不支持，@Bean举例如下：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
public class BeanConfiguration {
    @Bean({"bean1_1", "bean1_2"}) // 实例化一个Bean1设定其拥有两个BeanId，分别为bean1_1和bean1_2
    public Bean1 bean1() {
        return new Bean1();
    } 
}

七、引入其他注解了@Configuration的Class 或其他xml文件格式配置

可直接通过@Import实现，例如：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@Import(BeanConfiguration1.class)
@ImportResource("classpath:spring.xml")
public class BeanConfiguration { 
}

并且BeanConfiguration1无需注解@Configuration

public class BeanConfiguration1 {}

八、方法注入

可能存在如下场景：Class A 的某个方法依赖于Class B的实例，Class A使用scope=singleton单例模式，但是Class A每次执行方法的时候都希望获取一个新的Class B的实例，这个时候就用到了方法注入。举例：

@Component // 通过构造方法实例化bean
@Scope("prototype") // 设定bean作用域
public class Bean3 {
   
}

@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public abstract class Bean {
    @Lookup
    protected abstract Bean3 createBean3();
    public void printBean3() {
        System.out.println("createBean3().toString() = " + createBean3().toString());
    }
}

测试代码：

public class BeanTest {
    @Test
    public void testBean() throws Exception {
        final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
        Bean bean = context.getBean(Bean.class);    
        bean.printBean3();
        bean.printBean3();
        bean.printBean3();
      
    }
}

输出：

createBean3().toString() = [email protected]
createBean3().toString() = [email protected]
createBean3().toString() = [email protected]

可以看到Bean.printBean3()方法每次拿到的Bean3都是不同的实例

九、@PostConstruct和@PreDestroy

如果需要在Bean实例化完成之后或需要在Bean销毁之前执行一些逻辑，

可通过@PostConstruct和@PreDestroy实现。
可通过@Bean的initMethod和destroyMethod实现。

@Component // 通过构造方法实例化bean
public class Bean1 {

    public Bean1() {
        System.out.println(this.getClass().getSimpleName() + ":" + this.toString() + " has been created");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println(this.getClass().getSimpleName() + ":postConstruct()");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println(this.getClass().getSimpleName() + ":preDestroy()");
    }
}

public class Bean4 {

    public Bean4() {
        System.out.println(this.getClass().getSimpleName() + ":" + this.toString() + " has been created");
    }

    public void init() {
        System.out.println(this.getClass().getSimpleName() + ":init()");
    }

    public void destroy() {
        System.out.println(this.getClass().getSimpleName() + ":destroy()");
    }

}

测试：

@Test
public void testBean() throws Exception {
    final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
    System.out.println("=================context has bean created=====================");
    context.close();
}

输出：

Bean1:[email protected] has been created
Bean1:postConstruct()
Bean4:[email protected] has been created
=================context has bean created=====================
Bean4:init()
Bean4:destroy()
Bean1:preDestroy()

十、SpringIoC容器本身接口实例注入

Spring支持我们直接注入其相关接口实例，例如：ApplicationContext、BeanFactory、Environment、ResourceLoader、ApplicationEventPublisher、MessageSource接口及其实现类，举例其中一个说明：

@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public class Bean {

    private ApplicationContext context;

    public ApplicationContext getContext() {
        return context;
    }

    @Autowired // 可直接将ApplicationContext注入进来，也可以注入BeanFactory、Environment、ResourceLoader、ApplicationEventPublisher、MessageSource及其实现类
    public void setContext(ApplicationContext context) {
        this.context = context;
    }
}

以上是关于SpringIOC入门的主要内容，如果未能解决你的问题，请参考以下文章

Java技术篇！阿里java面试宝典

全网首发！java将内容写入文件

java主流框架ssm，附带学习经验

十年Java编程开发生涯，java获取数组最大值的函数

java数组赋值给另一个数组，2021最新版！

Java开发需要学什么！在java中创建线程有几种方法