目录
一、spring简介
1.1、什么是Spring
1.2 IOC
1.3、DI
二.创建Spring项目
2.1 创建一个普通的maven项目
2.2 引入maven依赖
三、Spring的创建和使用
3.1 创建Bean
3.2 将Bean放入到容器中
3.3 获取Bean对象
3.4、创建 Spring 上下文
3.5 获取指定的 Bean 对象
四、引入注解的方式
4.1 类注解
4.2 方法注解
4.3 传递参数
五、对象装配
5.1 属性注入
1.@Autowired注解
2.@Resource注解
3.Setter方法注入
4.构造函数注入
5.2 三种方法的优缺点
1.属性注入
2.Setter注入(Spring 3.X推荐)
3.构造函数注入(Spring 4.X推荐)
六.Bean的作用域
6.1 六种作用域简介
6.2 singleton
6.3 prototype
6.4 request
6.5 session
6.6 application
7.7 websocket:
七.Spring的启动流程
八.Bean的生命周期
spring简单的使用方式:使用注解的方法
因为用的是JDK17,需要用spring6.几的版本才行
org.springframework
spring-context
6.1.2
Bean注解默认名字,前两个字母都是大写就得是原名,只有首字母大写,会是全小写
Spring 指的是 Spring Framework(Spring 框架)
它可以让 Java 企业级 的应用程序开发起来更简单。
⽤⼀句话概括 Spring:Spring 是包含了众多工具方法的 IOC 容器。
IoC = Inversion of Control 翻译成中文是“控制反转”的意思,也就是说 Spring 是⼀个“控制反转”的容器,具体这里指对于依赖对象控制器的反转.
通常一个类
class A{
B b=new B();
}
这个B对象的生命周期是由A类来管理的,现在Spring将B的生命周期交给Spring来统一管理.这样就发生了控制权的反转.
当我们创建一个车的时候,要先创建车身,车身又需要底盘,底盘又依赖于轮胎,这样一层一层的依赖,使代码的耦合度很高
IOC的主要优势就是 程序解耦,耦合度降低
Spring 是一个 IoC(控制反转)容器,重点还在“容器”二字上,那么它就具备两个最基础的功
DI 是 Dependency Injection 的缩写,翻译成中文是“依赖注入”的意思。
如果说IOC是一种思想的话,那么DI就是思想的实现
我这里是用的jdk17,所以spring的版本要比较高的才行
org.springframework
spring-context
6.1.2
引入依赖之后,刷新一下maven就能引入了
Bean就是Java中一个普通的对象
在创建好的项目中添加 Spring 配置文件 spring-config.xml,将此⽂件放到 resources 的根目录下
Spring 配置⽂件的固定格式为以下内容:
接下来我么只需要将student对象注册到spring容器中即可
id为唯一标识这个student对象的.class为Student对象的位置
获取并使用 Bean 对象,分为以下 3 步:
1. 得到 Spring 上下文对象,因为对象都交给 Spring 管理了,所以获取对象要从 Spring 中获 取,那么就得先得到 Spring 的上下文。
2. 通过 Spring 上下文,获取某一个指定的 Bean 对象。
3. 使用 Bean 对象。
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
}
除了 ApplicationContext 之外,我们还可以使用 BeanFactory 来作为 Spring 的上下文,如下代码所示:
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spirng-config.xml"));
ApplicationContext 和 BeanFactory 效果是一样的,ApplicationContext 属于 BeanFactory 的子类,
他们的区别如下
BeanFactory 提供了基础的访问容器的能力,而 ApplicationContext属于 BeanFactory 的子类,它除了继承了 BeanFactory 的所有功能之外,它还拥有独特的特性,还添加了对国际化支持、资源访问支持、以及事件传播等方面的支持。
- 从性能方面来说:ApplicationContext 是一次性加载并初始化所有的 Bean 对象(预加载),而BeanFactory 是需要那个才去加载那个(懒加载),因此更加轻量。
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
User user = (User)context.getBean("user");
user.show();
}
通过在xml文件里定义的bean的id可以获取到相应的对象.
base-package = “com.zyf”,表示的是要扫描的路径是com.zyf下面的类
五大注解@Controller @Service @Repository @Component @Configuration
每一个注解上面都有@Component,说明这几个注解都是 @Component注解的子类,所以他们实现的功能都是一样的,那为什么还要有这么多不同的注解呢?
让程序员看到类注解之后,就能直接了解当前类的用途,比如:
命名规范:
注解生成bean的id为类的名称的首字母小写.当首字母和第二个字母都为大写字母的时候,直接返回原名字.
@Controller
public class Student {
private int age;
private String name;
public Student(){
}
public void show(){
System.out.println("show()");
}
}
public class App {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
Student student = (Student) applicationContext.getBean("student");
student.show();
}
}
通过注解,不用一个一个添加Bean到xml当中,让spring帮我们去扫描指定的路径就行
1. 方法注解需要搭配类的五大注解来使用
2. Bean对应的bean名是方法名
3 Bean重命名之后,就只能用自己定义的名字了
1、五大注解的方式:
2、之前配置Bean的形式
现在要求将UserService注入到UserController类中
先来创建service类
@Service
public class UserService {
public User getUser(Integer id) {
User user = new User();
user.setAge(id);
user.setName("zyf-"+id);
return user;
}
}
再来创建controller类
@Controller
public class UserController {
@Autowired
UserService userService;
public User getUser(Integer id) {
return userService.getUser(id);
}
}
测试:
public class App3 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
UserController userController = (UserController)context.getBean("userController");
userController.getName(18);
}
}
在进行类注入时,除了可以使用 @Autowired 关键字之外,我们还可以使⽤ @Resource 进行注入,如下代码所示:
@Controller
public class UserController {
@Resource
UserService userService;
public User getUser(Integer id) {
return userService.getUser(id);
}
}
同时 @Resource注解可以注入指定名字的对象
@Resource(name = "aaa") / /代表注入name=aaa的对象
UserService userService;
区别
只是Autowired的位置改变就行了
//Setter 注入
@Controller
public class UserController2 {
private UserService userService;
//只是Autowired的位置变化就行了
@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}
public void getName(Integer id){
userService.getUser(id);
}
}
通过构造函数注入,只有一个构造函数,可以省略@Autowired注解,如果存在多个构造函数,需要在使用的那个构造函数上面加@Autowired注解,否则就会报如下错误
优点:
缺点:
优点:
缺点:
优点:
缺点:
限定程序中变量的可用范围叫做作用域,或者说在源代码中定义变量的某个区域就叫做作用域。 而 Bean 的作用域是指 Bean 在 Spring 整个框架中的某种行为模式,比如 singleton 单例作用域,就 表示 Bean 在整个 Spring 中只有一份,它是全局共享的,那么当其他人修改了这个值之后,那么另一个人读取到的就是被修改的值。
注意后 4 种状态是 Spring MVC 中的值,在普通的 Spring 项目中只有前两种
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
public class Users {
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Bean(name = "u1")
public User user1() {
User user = new User();
user.setId(1);
user.setName("Java"); // 【重点:名称是 Java】
return user;
}
}
@Scope 标签既可以修饰方法也可以修饰类,@Scope 有两种设置方式:
1. 直接设置值:@Scope("prototype")
2. 使用枚举设置:@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
1、启动容器
2、解析配置文件的内容,并创建bean
Bean 执行流程(Spring 执行流程):启动 Spring 容器 -> 实例化 Bean(分配内存空间,从无到
有) -> Bean 注册到 Spring 中(存操作) -> 将 Bean 装配到需要的类中(取操作)。
bean的生命周期即对象从诞生到销毁的整个过程,我们把这个过程叫做一个对象的生命周期
把这个过程类比于买房的话就是如下