Java spring框架

一.为什么要学习spring框架

相对比与之前的Servlet，spring有以下一些优点：
1.添加外部jar包更容易
2.调试以及发布项目更方便（java - jar xxxx.jar发布）

1.什么是spring

spring指的是Spring FrameWork（spring框架）----------spring是包含了众多工具方法的Ioc容器。

2.什么是IoC容器

IoC是指Inversion of Control，翻译成中文就是控制反转，如何理解，简单来说就是对生命周期的托管，可以降低代码之间的耦合度，关联性变小。常见的方法有依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）

3.IoC和DI的区别

广义上来说IoC和DI是一个东西，如果说非要有什么区别：
IoC是一个设计思想，而DI去把这个思想实现了。比如：我今天很开心，想去吃顿好的。这个可以理解成IcO思想，而我去吃什么，像KFC，麦当劳等，具体吃什么可以理解成DI。

4.Spring核心功能

1.将对象存入到容器
2.从容器中取出对象
spring和普通程序的区别进一步理解
~把对象存储到容器的好处：把对象存储在IoC容器相当于你有个仓库，你把制作好的工具都放在仓库中，当你使用的时候可以直接去取，而传统的new方法是，你什么时候想用这个工具了，你再去制作，制作完就扔掉了。相比之下把对象放在IoC容器中会使程序效率更高。

二.创建spring项目

1.总体分为3步骤

1.创建一个普通的Maven项目
2.添加Spring框架支持（spring-context，spring-beans）
3.添加启动类

2.创建Maven项目

2.1
2.2

2.3

3.添加spring依赖

3.1建立完Maven项目后

3.2添加spring依赖

3.3在创建好的项⽬中添加 Spring 配置⽂件 spring-config.xml，将此⽂件放到 resources 的根⽬录下

3.4创建包以及测试类


3.5创建启动类

上述getBean也可以这样写：名称+类.class

4.创建spring总结

4.1操作容器之前要先有容器
4.2存对象
a：创建Bean（普通类）
b：将Bean注册到spring-config.xml
4.3取出对象
a：先得到spring上下文，并且读取到spring-config.xml配置文件
b：获取Bean对象，比如上述的UserService
c：使用Bean对象，比如上述使用userService.sayHi();

三.Spring简单的读取

1.引入简单的读取的原因

上述二已经讲述了如何创建Bean并且使用Bean，操作起来比较麻烦，我们每次都要在spring-config.xml中添加我们的Bean，要是有很多个，那么我岂不是要添加很多次

2.spring的扫描路径

我们上述已经使用了扫描路径了

3.使用添加注解存储Bean对象

将对象存储在Spring中，有2种类型可以实现
1.类注解：@Controller，@Service，@Repository，@Componen，@Configuration
2.方法注解：@Bean
类注解使用方法：
a：添加类注解

添加完类注解后，我们可以在启动类中，使用类名首字母小写来调用

其他的类注解也是一样的道理。
也可以在类注解后面添加其他的名字，在启动类中也可以比如@Controller(“aaa”);


所以类注解可以重命名的但是要注意，只能取一个名字，与@Bean方法注解不一样，@Bean可以取多个名字

注意：说明一下存储Bean命名的问题：
如果类的名字首字母大写第二个字母小写，那么Bean的名称可以通过类名小写来进行获取Bean对象。如果不满足首字母大写，第二个字母小写，那么则不能通过首字母小写来调用Bean对象

4.方法注解@Bean存储Bean对象

@Bean存储Bean对象时，要和五大注解一起使用（五大注解 注解在类上）

@Bean获取时：@Bean的默认名=方法名
重命名@Bean的几种方法：
1.@Bean(“aaa”)
2.@Bean(name = “bbb”)
3.@Bean(value = “ccc”)
4.@Bean(value = {“ddd”,“eee”})

注意：当@Bean重命名之后，那么默认的使用方法名获取Bean对象就获取不到了

四.获取Bean对象

1.获取Bean对象的三种方法

获取bean对象也叫做对象装配，是把对象取出来放到某个类中，也叫做对象注入
对象注入的实现有3种方法：
1.属性注入
2.Setter注入
3.构造方法注入

1.1属性注入

属性注入是使用@Autowired实现的

属性注入的优点：
1.实现简单
缺点：
a）无法注入final修饰的变量

因为final的特征是：
1.被final修饰的变量需要直接赋值
2.在构造方法中进行赋值

b）通用性问题：属性注入只适用于IoC容器
c）违背了单一设计原则

1.2Setter注入

setter注入和属性的setter相似，不过setter注入需要在设置set方法时加上@Autowired注解

setter注入的优缺点：
优点：
1.setter只set一个属性，所以setter注入更符合单一设计原则
缺点：
1.无法注入一个final修饰的变量
2.由于setter注入是一个方法，所以有可能会被多次调用，有被修改的风险

1.3构造方法注入

构造方法的优缺点
优点：
1.可以注入一个final修饰的变量
2.注入的对象不会被修改，因为构造方法只会被执行一次
3.构造方法注入可以保证注入对象完全初始化
4.构造方法注入通用性好

缺点：
1.比属性注入复杂
2.使用构造方法注入，无法理解循环依赖的问题

2.@Autowired和@Resource的区别

1.出身不同：@Autowired来自于spring，而@Resource来自于JDK的注解
2.使用时设置的参数不同，对于@Autowired来说，@Resource支持更多的参数设置，比如，name设置，根据名称来获取Bean
3.@Autowired可以用于Setter注入，构造函数注入和属性注入，而@Resource只能用于Setter注入和属性注入，不能用于构造函数注入

3. 综合练习

在 Spring 项⽬中，通过 main ⽅法获取到 Controller 类，调⽤ Controller ⾥⾯通过注⼊的⽅式调⽤Service 类，Service 再通过注⼊的⽅式获取到 Repository 类，Repository 类⾥⾯有⼀个⽅法构建⼀个 User 对象，返回给 main ⽅法。Repository ⽆需连接数据库，使⽤伪代码即可。
解析：
1.创建好对应的Controller，Service，model，Repository包以及类

2.在model中的User中，创建一些属性，重写toString方法

package com.cauchy.demo.model;
public class User {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "UserRepository{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.按照题目要求，一次把UserRepository，UserService，UserController写完，一次如下

package com.cauchy.demo.repository;

import com.cauchy.demo.model.User;
import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    public User getUser(){
        User user = new User();
        user.setAge(111);
        user.setName("张三");
        return user;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.cauchy.demo.service;

import com.cauchy.demo.model.User;
import com.cauchy.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    public User getUser(){
        return userRepository.getUser();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package com.cauchy.demo.controller;

import com.cauchy.demo.model.User;
import com.cauchy.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    @Autowired
    private UserService userService;
    public User getUser(){
        return userService.getUser();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在启动类App里面测试即可

package com.cauchy.demo;
import com.cauchy.demo.controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserController userController = context.getBean("userController", UserController.class);
        System.out.println(userController.getUser());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

五.Bean作用域和生命周期

1.作用域定义

限定程序中变量的可用范围叫做作用域，在代码中定义变量的某个区域叫做作用域。
对于Bean来说，它的作用域是指Bean在spring整个框架中的某种行为模式，比如singleto单例作用域，表示Bean在整个spring中只有一次，并且是全局共享的，当其他人修改了这个值之后，那么另一个人读取到的就是被修改的数值。

2.Bean的6种作用域

1.singleton：单例作用域
2.prototype：原型作用域
3.request：请求作用域
4.session：回话作用域
5.application：全局作用域
6.websocket：HTTP WebSocket作用域

注意：最后四种状态是Spring MVC中的值，在普通的spring项目中只有前两种。

2.1 singleton单例作用域

描述：该作用域下的Bean在IoC容器中只能存在一个实例：获取Bean（通过ApplicationContext.getBean等方法）以及装配Bean（通过@Autowired注入）
场景：无状态的Bean使用该作用域。无状态表示Bean对象的属性状态不需要更新
备注：Spring默认选择单例作用域

2.2 prototype原型作用域

在上述我们知道，@Bean是默认singleton模式，于是会出现上述当其他人修改这个数值之后，其他人在获取的时候是已经被修改过的数值了。

解决方法是：