Java之Spring

IOC优点：实现代码的解耦，对象（Bean）生命周期交给Ioc框架维护，作为程序员无需在关注了。
spring Ioc容器的最核心的功能：
（1）将Bean（对象）存储到spring（容器）中
（2）将Bean（对象）从spring（容器）中取出来

DI【依赖注入】和Ioc【控制反转】的区别
（1）Ioc是一种思想，而DI是一种实现
比如：想去吃饭，就是思想，而去吃了海底捞就是实现。

创建spring项目

（1）先创建一个maven项目

（2）添加spring框架支持（spring-context / spring-beans）
在pom.xml中添加如下代码

<dependencies>
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
  
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

设置国内源：

如果此目录下没有相应的settings.xml文件，把相应的文件拷贝进来。

（3）创建一个启动类并添加main

创建一个类。类名可以任意取。

执行结果：

存储bean对象到容器（spring）中

（1）先在spring项目中添加配置文件，如果不是第一次配置，则此步骤可以省略。

<?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">
    
</beans>

将上述代码片段放置到创建的xml中【配置文件的名字可以任意取，此处取的是spring-config.xml】

（2）创建bean对象
在Java中就是普通的对象。
创建一个User对象

package com.beans;

public class User {
    public void sayHi(String name) {
        System.out.println("你好:"+name);
    }
}

（3）在配置文件中将需要保持到spring中的对象进行注册。
将bean通过配置文件注册到spring中。

从spring中将bean取出

（1）先得到spring上下文对象

 // 1. 得到spring上下文对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");

（2）通过上下文对象提供的getBean方法获取自己需要使用的bean对象

//2. 根据上下文对象提供的方法获取到bean
        User user=(User) context.getBean("user");

（3）使用bean对象【可选步骤】

//3.使用bean
        user.sayHi("李四");

除了 ApplicationContext 之外，我们还可以使⽤ BeanFactory 来作为 Spring 的上下⽂。

//另一种方法
        //1.得到bean工厂
        BeanFactory factory=new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        // 2. 获取bean
        User user=(User) factory.getBean("user");
        //3.使用bean
        user.sayHi("张三");

ApplicationContext和 BeanFactory的区别？
相同点：都可以实现从容器中获取bean，都提供了getBean的方法。
不同点：

1. ApplicationContext属于BeanFactory的子类。BeanFactory只是提供了基础访问bean的方法，而 ApplicationContext除了拥有BeanFactory所有功能之外，还提供了更多的方法实现，比如对国际化的支持。
2. 从性能方面来说二者是不同的，BeanFactory是按需加载bean，ApplicationContext是饿汉方式，在创建时会将所有的bean都加载起来，以备以后使用。

getBean的更多用法：
（1）使用bean name获取bean

User user=(User) context.getBean("user");

（2）根据bean type 获取bean

User user= context.getBean(User.class);

此方法写法简单，但容易出问题。当同一个类型被注入到spring中多次的时候，就会报错。

（3）根据bean name和类型获取bean

 User user=context.getBean("user",User.class);

更简单的读取存储对象

在 Spring 中想要更简单的存储和读取对象的核⼼是使⽤注解。

存储bean对象

前置准备

在spring配置文件中设置bean扫描根路径
在resource下创建spring-config.xml，将下述代码写入spring-config.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"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <content:component-scan base-package=""></content:component-scan>
</beans>

添加注解存储 Bean 对象

想要将对象存储在 Spring 中，有两种注解类型可以实现：

1. 类注解：@Controller【控制器】、@Service【服务】、@Repository【仓库】、@Component【组件】、@Configuration【配置】。

为什么需要5大类注解？
让代码的可读性提高，让程序员能够直观的判断当前类的用途。

5大类注解之间有何关系
@Controller【控制器】、@Service【服务】、@Repository【仓库】、@Configuration都是基于@Component【组件】实现的，所以@Component【组件】可以认为是其他4个注解的父类。

关于bean name的规则：
如果类名是大驼峰，则bean name使用小驼峰，如果类名的第一个和第二个字母是大写的，则bean name是原类名。

2. ⽅法注解：@Bean
   在 Spring 框架的设计中，⽅法注解 @Bean 要配合类注解才能将对象正常的存储到 Spring 容器中
   

@Component
public class UserBeans {
    @Bean//注：只使用一个bean注解是无法将对象存储到容器中
    public User user1(){
        User user=new User();
        user.setId(1);
        user.setName("张丹");
        return user;

    }

}

bean命名规则：当没有设置name属性时，那么bean默认的名称就是方法名，当设置了那么属性后，只能通过重命名的name属性对应的值类获取，也就是说重命名之后，在使用方法名就获取不到bean对象。

获取bean对象

获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注⼊。
对象装配（对象注⼊）的实现⽅法以下 3 种：

1. 属性注⼊

@Controller
public class UserController2 {
    //对象注入方式1： 属性注入
    @Autowired
    private UserService userService;
    public void sayHi() {
        userService.sayHi();
    }


}

//属性注入
        UserController2 userController2=context.getBean(UserController2.class);
        userController2.sayHi();

2. 构造⽅法注⼊

//使用构造方式实现bean注入(官方推荐)
@Controller
public class UserController3 {
    private  UserService userService;

    @Autowired
    public UserController3(UserService userService) {
        this.userService=userService;

    }
    public  void sayHi(){
        userService.sayHi();
    }
}

//构造方法注入
      UserController3 userController3=context.getBean(UserController3.class);
      userController3.sayHi();

3. Setter 注⼊

@Controller
public class UserController4 {
    private UserService userService;
     @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public  void sayHi() {
         userService.sayHi();
    }

}

//setter注入
        UserController4 userController4=context.getBean(UserController4.class);
        userController4.sayHi();

属性注入、构造方法注入、setter注入的区别是什么？

1. 属性注入特点：写法简单，但是通用性不好，它只能运行在Ioc容器下，如果是非Ioc容器就会出现问题。
2. setter注入：早期spring版本推荐的写法。setter注入通用性没有构造方法注入通用。
3. 构造方法注入：通用性更好。它能确保在使用注入对象之前，此注入对象一定初始化过了。当构造方法注入参数过多时，此时开发者就要检查自己写的代码是否符合单一设计原则的规范了，此注入 方式也是spring后期版本中推荐的注入方式。

另一种注入注解:@Resource
注：@Resource支持属性注入和setter注入，但不支持构造方法注入。

@Resource 和 @Autowired的区别？
都可以实现将对象注入到当前类当中。

1. @Resource来自于JDK， @Autowired是spring框架提供的。
2. 用法不同： @Autowired支持属性注入、构造方法注入和setter注入，而@Resource不支持构造方法注入。
3. 支持的参数不同： @Resource支持更多的参数设置，比如name、type，而@Autowired只支持一种。

bean作用域和生命周期

定义

bean的作用域：bean在spring整个框架中的某种行为。

bean的6种作用域

1. singleton:单例模式（默认）
2. prototype：原型模式（多例模式）
3. request：请求模式（适用于spring MVC）
4. session：会话作用域（spring MVC）【一个会话共享一个对象】
5. application：全局作用域（spring MVC）
6. websocket：HTTP WebSocket作用域（spring WebSocket）

bean生命周期

1. 实例化bean（为bean分配内存空间）
2. 设置属性（对象注入）
3. 初始化
   （1）执行各种通知
   （2）执行初始化前置方法
   （3）执行构造方法，有两种方式，一是执行@PostConstruct,另一种是init-method
   （4）执行初始化的后置方法
4. 使用bean
5. 销毁bean
   （1）@PreDestroy
   （2）重写DisposableBean接口方法
   （3）destroy-method