Java Spring

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.2</version>
</dependency>

<?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="com.zyf"></content:component-scan>
</beans>

Bean注解默认名字，前两个字母都是大写就得是原名，只有首字母大写，会是全小写

一、spring简介

1.1、什么是Spring

Spring 指的是 Spring Framework（Spring 框架）

它可以让 Java 企业级的应用程序开发起来更简单。

??句话概括 Spring：Spring 是包含了众多工具方法的?IOC 容器。

1.2 IOC

IoC = Inversion of Control 翻译成中文是“控制反转”的意思，也就是说 Spring 是?个“控制反转”的容器,具体这里指对于依赖对象控制器的反转.

通常一个类

class A{
B b=new B();
}

这个B对象的生命周期是由A类来管理的,现在Spring将B的生命周期交给Spring来统一管理.这样就发生了控制权的反转.

当我们创建一个车的时候,要先创建车身,车身又需要底盘,底盘又依赖于轮胎,这样一层一层的依赖,使代码的耦合度很高

IOC的主要优势就是?程序解耦,耦合度降低

Spring 是一个 IoC（控制反转）容器，重点还在“容器”二字上，那么它就具备两个最基础的功

将对象存入到容器；
从容器中取出对象。

1.3、DI

DI 是 Dependency Injection 的缩写，翻译成中文是“依赖注入”的意思。

如果说IOC是一种思想的话，那么DI就是思想的实现

二.创建Spring项目

2.1 创建一个普通的maven项目

2.2? 引入maven依赖

我这里是用的jdk17，所以spring的版本要比较高的才行

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.2</version>
</dependency>

引入依赖之后，刷新一下maven就能引入了

三、Spring的创建和使用

3.1? 创建Bean

Bean就是Java中一个普通的对象

3.2? 将Bean放入到容器中?

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

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

接下来我么只需要将student对象注册到spring容器中即可

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

id为唯一标识这个student对象的.class为Student对象的位置?

3.3 获取Bean对象

?获取并使用 Bean 对象，分为以下 3 步：
? ? ? ? 1. 得到 Spring 上下文对象，因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获? ? ? ? ? ?取，那么就得先得到 Spring 的上下文。

????????2. 通过 Spring 上下文，获取某一个指定的 Bean 对象。
? ? ? ? 3. 使用 Bean 对象。? ? ?

3.4、创建 Spring 上下文

 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 是需要那个才去加载那个(懒加载)，因此更加轻量。

3.5? 获取指定的 Bean 对象??

 public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

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

通过在xml文件里定义的bean的id可以获取到相应的对象.

四、引入注解的方式

4.1 类注解

<?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="com.zyf"></content:component-scan>
</beans>

base-package = “com.zyf”，表示的是要扫描的路径是com.zyf下面的类

?五大注解@Controller? @Service @Repository? @Component? @Configuration

每一个注解上面都有@Component,说明这几个注解都是?@Component注解的子类,所以他们实现的功能都是一样的,那为什么还要有这么多不同的注解呢?

让程序员看到类注解之后，就能直接了解当前类的用途，比如：

@Controller：表示的是业务逻辑层；
@Servie：服务层；
@Repository：持久层；
@Configuration：配置层。
@Compoent:其他层

命名规范:

注解生成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帮我们去扫描指定的路径就行

4.2 方法注解

1. 方法注解需要搭配类的五大注解来使用

2. Bean对应的bean名是方法名

3 Bean重命名之后，就只能用自己定义的名字了

4.3 传递参数

1、五大注解的方式：

2、之前配置Bean的形式

五、对象装配

5.1 属性注入

1.@Autowired注解

现在要求将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);
    }
}

2.@Resource注解

在进行类注入时，除了可以使用 @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 来自于 Spring，而 @Resource 来自于 JDK 的注解；
?使用时设置的参数不同：相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如name 设置，根据名称获取 Bean。
@Autowired 可用于 Setter 注入、构造函数注入和属性注入，而 @Resource 只能用于 Setter 注入和属性注入，不能用于构造函数注入。
当然@Autowired搭配@qualiier能实现指定

3.Setter方法注入

只是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);
    }
}

4.构造函数注入

通过构造函数注入,只有一个构造函数,可以省略@Autowired注解,如果存在多个构造函数,需要在使用的那个构造函数上面加@Autowired注解,否则就会报如下错误

5.2?三种方法的优缺点

1.属性注入

优点:

简洁，使用方便;

缺点:

只能用于lOC容器，如果是非IOC容器不可用，并且只有在使用的时候才会出现NPE（空指针异常)。
不能注入一个final修饰的属性

2.Setter注入(Spring 3.X推荐)

优点:

方便在类实例之后，重新对该对象进行配置或者注入

缺点:

不能注入一个final修饰的属性
注入对象可能会被改变,因为setter方法可能会被多次调用,就有被修改的风险.?

3.构造函数注入(Spring 4.X推荐)

优点:

可以注入final修饰的属性
注入的对象不会被修改
依赖对象在使用前一定会被完全初始化，因为依赖是在类的构造方法中执行的，而构造方法是在类加载阶段就会执行的方法。
通用性好,构造方法是JDK支持的,所以更换任何框架,他都是适用的。

缺点:?

注入多个对象时,代码会比较繁琐

六.Bean的作用域

6.1? ?六种作用域简介

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

singleton：单例作用域(默认)
prototype：原型作用域（多例作用域）
request：请求作用域
session：会话作用域
application：全局作用域
websocket：HTTP WebSocket 作用域

注意后 4 种状态是 Spring MVC 中的值，在普通的 Spring 项目中只有前两种

6.2?singleton

官方说明：(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
描述：该作用域下的Bean在IoC容器中只存在一个实例：获取Bean（即通过applicationContext.getBean等方法获取）及装配Bean（即通过@Autowired注入）都是同一个对象。
场景：通常无状态的Bean使用该作用域。无状态表示Bean对象的属性状态不需要更新
备注：Spring默认选择该作用域

6.3 prototype

官方说明：Scopes a single bean definition to any number of object instances.
描述：每次对该作用域下的Bean的请求都会创建新的实例：获取Bean（即通过pplicationContext.getBean等方法获取）及装配Bean（即通过@Autowired注入）都是新的对象实例。
场景：通常有状态的Bean使用该作用域

6.4? request

描述：每次http请求会创建新的Bean实例，类似于prototype
场景：一次http的请求和响应的共享Bean
备注：限定SpringMVC中使用

6.5??session

官方说明：Scopes a single bean definition to the lifecycle?of an HTTP Session. Only valid inthe context of a web-aware Spring ApplicationContext.
描述：在一个http session中，定义一个Bean实例
场景：用户回话的共享Bean, 比如：记录一个用户的登陆信息
备注：限定SpringMVC中使用

6.6??application

官方说明：Scopes a single bean definition to the lifecycle of a ServletContext.Only valid in?the context of a web-aware Spring ApplicationContext.
描述：在一个http servlet Context中，定义一个Bean实例
场景：Web应用的上下文信息，比如：记录一个应用的共享信息
备注：限定SpringMVC中使用

7.7??websocket：

官方说明：Scopes a single bean definition to the lifecycle of a WebSocket.Only valid in thecontext of a web-aware Spring ApplicationContext.
描述：在一个HTTP WebSocket的生命周期中，定义一个Bean实例
场景：WebSocket的每次会话中，保存了一个Map结构的头信息，将用来包裹客户端消息头。第一次初始化后，直到WebSocket结束都是同一个Bean。
备注：限定Spring WebSocket中使用

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)

七.Spring的启动流程?

1、启动容器

2、解析配置文件的内容,并创建bean

3、把对象放入容器当中

4、bean对象依赖装配

Bean 执行流程（Spring 执行流程）：启动 Spring 容器 -> 实例化 Bean（分配内存空间，从无到

有） -> Bean 注册到 Spring 中（存操作） -> 将 Bean 装配到需要的类中（取操作)。

八.Bean的生命周期

bean的生命周期即对象从诞生到销毁的整个过程,我们把这个过程叫做一个对象的生命周期

把这个过程类比于买房的话就是如下

文章来源:https://blog.csdn.net/flyingcloud6/article/details/135188998
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！