Spring框架-阿里云开发者社区

Spring框架

在软件开过程中，我们需要使用到实例。我们又期望这些实例以单例的形式存在。现在我们要获得单例没有一个统一的入口，这时候就有了Spring。

我们使用Spring将这些实例统一的管理起来了，如果要获得某个类型的实例，可以通过Spring来获得

使用Spring容器来管理实例，并且从Spring容器中取出实例

组件：Spring容器管理的实例叫组件

引入依赖

Spring的依赖5+1

spring-core\context\aop\expression\beans + jcl(日志包)

junit

Spring依赖的特征：spring-xxx(官方)、 xxx-spring(非官方)

<!--5+1-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.15.RELEASE</version>
</dependency>
<!--junit-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

配置文件

为啥要使用配置文件。使用配置文件将需要管理的实例做统一的管理

Spring配置文件是xml格式的 → 使用xml需要规范，xml中可以使用哪一些标签、可以使用哪一些属性，标签又有什么样的子标签 → 约束，同时也提供了解析的方式

我们需要去引入约束（头）

已有的项目复制（×）
文件模板（×）
Spring官方文档 →
→ schema约束

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
    <!-- bean definitions here -->
    <bean id="userService" class="proxy.service.UserServiceImpl"/>
</beans>

注册组件

我们要使用Spring容器管理组件

我们需要有对应的类，才能管理它的实例。

<!--注册组件 → UserServiceImpl-->
<!--id属性：组件在容器中唯一标识-->
<!--class属性：全限定类名 ctrl + alt + shift + c-->
 <bean id="userService" class="proxy.service.UserServiceImpl"/>

测试

@Test
public void test1(){
    ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext(
            "application.xml");//初始化容器
    //获得对象，建议用接口接收，方便后期修改维护
    UserService  userService = (UserService) classPathXmlApplicationContext.getBean("userService");
    userService.say();
}

取出组件的方式

getBean

//getBean(String)  → 按照组件id取出组件
//getBean(Class)   → 按照组件类型取出组件（该类型的组件只有一个）
//applicationContext.getBean(UserService.class)
//getBean(String,Class)  → 按照组件id和类型

@Test
public void mytest() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
    //按照组件id取出
    UserService userService1 = (UserService) applicationContext.getBean("userService");
    //按照类型取出
    UserService userService2 = applicationContext.getBean(UserService.class);
    //按照组件id和组件类型
    UserService userService3 = applicationContext.getBean("userService", UserService.class);
    userService1.sayHello("world");
}

最好使用id+组件类型共同配合，这样可以避免类型强转出现的问题

当使用按照类型取出的时候，如果相同类型的组件不止一个，那么就会出现问题

<bean id="userService" class="com.cskaoyan.service.UserServiceImpl"/>
<bean id="userService2" class="com.cskaoyan.service.UserServiceImpl2"/>

会出现以下的异常

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type ‘com.cskaoyan.service.UserService’ available: expected single matching bean but found 2: userService,userService2

维护多个组件之间的关系

即，在一个组件中维护其他组件中的对象

<bean id="userService" class="com.cskaoyan.service.UserServiceImpl">
    <!--name属性：给成员赋值，使用的是set方法赋值的-->  
    <!--ref属性：引用了容器中的组件的id-->
    <property name="userDao" ref="userDao"/>
</bean>
<bean id="userDao" class="com.cskaoyan.dao.UserDaoImpl"/>

核心接口

容器接口：ApplicationContext、BeanFactory（ApplicationContext的父接口）

ApplicationContext：ClassPathXmlApplicationContext、AnnotationConfigApplicationContext、WebApplicationContext

Spring底层就是维护了一个HashMap

BeanFactory和FactoryBean之间的关系？

联系：都是工厂设计模式，都是向容器中注册组件

区别：BeanFactory注册的全部组件；FactoryBean注册的是特定的组件

BeanFactory:负责生产和管理Bean的一个工厂接口，提供一个Spring Ioc容器规范,
FactoryBean: 一种Bean创建的一种方式，对Bean的一种扩展。对于复杂的Bean对象初始化创建使用其可封装对象的创建细节。

Bean的实例化

构造方法

无参构造和有参构造皆可，默认使用的是无参构造，可以通过property来进行赋值

<!--默认使用的是无参构造-->
<bean id="noParamConstructorBean" class="com.cskaoyan.bean.NoParamConstructorBean">
    <property name="username" value="songge"/>
</bean>

如果要使用有参构造，那么需要在子标签中写入构造方法的形参名

<bean id="hasParamConstructorBean" class="com.cskaoyan.bean.HasParamConstructorBean">
    <!--name属性：有参构造方法的形参名-->
    <constructor-arg name="username" value="ligenli"/>
</bean>

工厂

静态工厂和实例工厂

静态工厂注册：

<bean id="carFromStaticFactory" class="com.cskaoyan.factory.CarStaticFactory" factory-method="create"/>

指明调用静态工厂中的方法名即可，会自动调用并产生实例，使用factory-method标签

实例工厂注册：首先要用无参构造完成工厂的实例化，然后再调用实例工厂的工厂方法

<!--工厂的实例化 → 无参构造先完成工厂的实例化-->
<bean id="instanceFactory" class="com.cskaoyan.factory.CarInstanceFactory"/>

<!--使用工厂实例调用生产方法:唯一一个没有使用class属性的bean标签-->
<bean id="carFromInstanceFactory" factory-bean="instanceFactory" factory-method="create"/>

***FactoryBean

将方法的返回值作为容器中的组件

工厂方法：定义工厂接口，来实现工厂接口

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
    //getObject是其核心方法 → 返回值作为容器中的组件
    //类定义的泛型体现在返回值类型
    @Nullable
    T getObject() throws Exception;
    //组件类型
    @Nullable
    Class<?> getObjectType();
    default boolean isSingleton() {
        return true;
    }
}

在注册组件的时候有个命名的规则xxxFactoryBean，注册的组件就是xxx

/**
 * FactoryBean
 * XXXFactoryBean → 注册的组件就是XXX
 * @author stone
 * @date 2021/12/25 11:31
 */
public class CarFactoryBean implements FactoryBean<Car> {
    @Override
    public Car getObject() throws Exception {
        Car car = new Car();
        car.setSource("factory bean");
        return car;
    }
    @Override
    public Class<?> getObjectType() {
        return Car.class;
    } 
}

组件注册

只需要将FactoryBean注册到容器中即可

<!--FactoryBean只需要注册到容器中-->
<bean id="carFromFactoryBean" class="com.cskaoyan.factory.CarFactoryBean"/>

FactoryBean是Spring框架中非常特殊的一个接口，我们注册组件的时候，我们写的是其其实现类，而最终取出的组件是其getObject方法的返回值

Srping容器在取出bean的时候，会先判断这个bean有没有实现FactoryBean，如果有就返回getObject中的返回值，如果没有就返回bean

Scope作用域

singleton 单例：每一次取出来是同一个

prototype 原型：每一次取出来是一个新的 → 每一次取出组件的时候才会开始生命周期

配置作用域

<bean id="singletonBean" class="com.cskaoyan.scope.SingletonBean" scope="singleton"/>
<bean id="prototypeBean" class="com.cskaoyan.scope.PrototypeBean" scope="prototype"/>
<bean id="defaultBean" class="com.cskaoyan.scope.DefaultBean"/>

默认的作用域是单例，绝大多数情况下我们使用的也是单例

生命周期

组件从实例化开始到组件可用状态这个时间经过哪些方法，在容器关闭的时候也会影响

Scope对生命周期的影响:

1. Prototype组件：每一次取出组件的时候才会开始生命周期 → 懒加载，容器关闭不会执行方法
2. Singleton组件：容器初始化的时候就已经开始生命周期 → 立即加载，容器关闭会执行方法

组件在容器中默认以单例的形式存在，单例组件在容器初始化时开始生命周期，生命周期的起点是Bean的实例化

Aware接口

如果你需要Aware提供的值，才去实现对应的接口，才会执行到对应的set方法

使用的是set方法进行赋值，需要使用一个成员变量接收。

设置BeanName

public interface BeanNameAware extends Aware {
    void setBeanName(String var1);
}

设置BeanFactory

public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory var1) throws BeansException;
}

设置上下文

public interface ApplicationContextAware extends Aware {
    void setApplicationContext(ApplicationContext var1) throws BeansException;
}

***BeanPostProcessor接口

BeanPostProcessor接口提供的方法是给容器中的所有的组件使用的，相当于是一个通用性的方法，容器中的所有组件都会执行到BeanPostProcessor的postProcessBeforeInitialization和postProcessAfternitialization方法

对所有的组件进行通用性的处理，也可以根据传入的参数来进行判断，对某一类或者某一个组件进行单独的处理

生效条件：首先定义一个类实现BeanPostProcessor接口，并且将其注册为容器中的组件。

针对于BeanPostProcessor而言，作用范围是：除了BeanPostProcessor这个组件之外，其他的所有组件

public interface BeanPostProcessor {
    /**
    * bean: 正在执行生命周期的组件
    * beanName: 正在执行生命周期的组件id
    * 返回值：Object类型，需要注册到容器中的实例
    */
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

针对于返回值，如果返回值为null那么就返回原先的bean，如果不是null，就返回自定义的值并注册到组件中

个性化处理：

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("组件" + beanName +"的BeanPostProcessor的before方法");
    //针对于容器中的某一类或某一个组件可以在这里做通用性的处理
    // 能否找到所有的DataSource组件做处理
    if (bean instanceof DataSource) {
        //个性化的处理
        // 数据库的密码是123456
        // 我这里可以获得配置文件中的abcdef
        // 把abcdef转换为你需要的123456
    }
    // 我能否找到lifeCycleBean这个组件
    if ("lifeCycleBean".equals(beanName)) {
        //原先的username是songge → 组件到达可用状态之前变成ligenli
        LifeCycleBean temp = (LifeCycleBean) bean;
        temp.setUsername("ligenli");
        return temp;
    }
    // 传入的是委托类的实例，返回的是代理对象
    return bean;
}

主要关注的是通用性，在通用性里也可以自己写代码完成个性化的处理

before和after之间的过程

InitializingBean接口提供的afterPropertiesSet方法

@Override
public void afterPropertiesSet() throws Exception { //在processor的before和after之间生效
    System.out.println(beanName+":afterPropertiesSet方法");
}

自定义的init方法

public void myinit() {  //需要使用init-method的标签告诉容器这是init方法
    System.out.println("自定义init");
}

使用自定义的init中的方法的时候需要在配置文件中加上init-method属性，告知容器这是这个实例的init方法

<bean id="lifeCycleBean" class="ioc1.lifeCycle.LifeCycleBean" init-method="myinit" >
    <property name="username" value="zs"/>
</bean>

注意

对于作用域是prototype的组件，每一次取出组件(getBean方法)的时候，才会开始生命周期，因为他是懒加载，这样就不用维护多余的内存空间。同时因为不是单例，那么每次加载的时候都是新的对象，也就会执行新的生命周期

容器关闭

容器在关闭的时候，会执行对应的方法，一般是为了方便资源的释放

一定要注意prototype类型的组件在容器关闭时不会执行对应的方法

DisposableBean提供的destroy方法

public interface DisposableBean {
    void destroy() throws Exception;
}

自定义的destroy方法

public void myDestroy(){
    System.out.println("自定义的destroy方法");
}

如果需要调用自定义的destroy方法，那么就需要在标签中指明该方法

<bean id="lifeCycleBean" class="ioc1.lifeCycle.LifeCycleBean" init-method="myinit" destroy-method="myDestroy">
    <property name="username" value="zs"/>
</bean>

如果自定义的destroy和DisposableBean提供的destroy方法同时都有，那么两个都会执行

这里要注意destroy方法必须要容器关闭才会执行，因此需要调用容器的close方法

applicationContext.close();

完整的生命周期的流程

1.实例化

2.参数设置–使用set方法–关联propert标签

3.如果组件实现了Aware接口，那么就会执行到Aware接口中提供的方法

4.执行BeanPostProcessor中的方法

4.1先执行beforeinit再执行afterinit

4.2如果在这中间有接口提供的或者自定义的init方法，那么就会执行

5.最后到达可用状态

注解

组件注册功能的注解

在注册的时候，使用注解和全限定类名耦合起来，并通过配置文件配置一个包目录，Spring可以自动找到这个包下的所有包含注册功能注解的类

1.限定范围

2.注册功能注解

扫描包的配置文件

<!--扫描包目录：扫描的是当前包以及它的所有的子包-->
<context:component-scan base-package="com.cskaoyan"/>

常用的注册组件的注解

@Component,  通用型
@Repository,  通常是dao层的组件
@Service,  通常是service层的组件
@Controller,  SpringMVC阶段的
@RestController,  SpringMVC阶段的
@ControllerAdvice,  SpringMVC阶段的
@Configuration   Spring的配置类使用的 → JavaConfig

通过注解注册的组件，组件的id是什么？

1.默认的id值是类名的首字母小写的形式

2.自行指定：使用注解的value属性来指定

//@Component //userServiceImpl → 组件id的默认值是类名的首字母小写的形式
//@Component(value = "userService")//使用注解的value属性指定
@Component("userService")//如果注解中只有value属性，‘value=’这一部分可以省略掉
public class UserServiceImpl implements UserService{
}

作用域

@Scope 直接写在类上，在value属性中直接写作用域即可，同样的，value属性可以省略，直接写值即可

@Scope("prototype") //value属性里直接写作用域就可以了
public class UserServiceImpl implements UserService{
}

生命周期中的init和destroy方法

@PostConstruct 表示的是init方法

@PreDestroy表示的是destroy方法

public class UserServiceImpl implements UserService{
    @PostConstruct //init-method
    public void myinit() {
        System.out.println("自定义init方法");
    }
    @PreDestroy //destroy-method
    public void mydestroy() {
        System.out.println("自定义destroy方法");
    }
}

注入功能的注解

组件的注入

在组件的成员变量中引入容器中已经注册的组件，维护组件之间的依赖关系

其实就是从容器中取出组件给成员变量赋值。取出组件的方式和getBean方法是类似的

1.按照组件类型取出

2.按照组件id取出

3.按照id和类型取出

@Autowired
@Qualifier("userDaoImpl1") //按照类型和id引入
UserDao userDao1;
@Resource(name = "userDaoImpl2") // 使用@Resource注解的name属性
UserDao userDao2;
@Autowired   //按照类型
OrderDao orderDao;

常用的方法是按照类型取出

值的注入

注入组件的成员变量：接收字符串、基本类型这样的一些值

可以使用@Value注解使用SpEL，需要首先加载properties配置文件如果要加载classpath路径，需要进行指定

<context:property-placeholder location="classpath:param.properties"/>

接下来在使用的时候直接用${}的形式来引入key，就可以自动获取key中的value的值

@Value("${userservice.username}") //${}引入key → SpEL → Spring Expression Language
String username;

这里要注意写key的时候一定要增加一个自定义的前缀名，这样可以更方便的分辨属性，并且也可以避免引入系统变量

注意事项

@Autowired、@Autowired+@Qualifier、@Resource、@Value

这些注解，要在容器中的组件才能使用，因为只有组件注册了，才可以取出

单元测试

Spring单元测试：方便从容器中取出实例

直接在单元测试类使用注入功能的注解来取出组件

在单元测试类中需要维护容器 → ApplicationContext → application.xml

单元测试类中会帮我们维护好容器

引入依赖

spring-test

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.15.RELEASE</version>
    <scope>test</scope>
</dependency>

单元测试类上的注解

@Runwith(SpringJUnit4ClassRunner.class) 加载测试类的注解

@ContextConfiguration(“classpath:application.xml”) 加载配置文件的注解，一定要带上classpath

@RunWith(SpringJUnit4ClassRunner.class)//注解是junit提供的，class是spring-test
@ContextConfiguration("classpath:application.xml")
public class AnnotationTest {
    @Autowired
    OrderDao orderDao;
    @Autowired
    UserService userService;
    @Autowired
    ApplicationContext applicationContext;
    @Test
    public void mytest1() {
        userService.serviceMethod();
    }
}

ork

spring-test

5.2.15.RELEASE

test

单元测试类上的注解
@Runwith(SpringJUnit4ClassRunner.class) 加载测试类的注解
@ContextConfiguration("classpath:application.xml") 加载配置文件的注解，一定要带上classpath
```java
@RunWith(SpringJUnit4ClassRunner.class)//注解是junit提供的，class是spring-test
@ContextConfiguration("classpath:application.xml")
public class AnnotationTest {
    @Autowired
    OrderDao orderDao;
    @Autowired
    UserService userService;
    @Autowired
    ApplicationContext applicationContext;
    @Test
    public void mytest1() {
        userService.serviceMethod();
    }
}

Spring框架

Spring框架

引入依赖

配置文件

注册组件

测试

取出组件的方式

维护多个组件之间的关系

核心接口

Bean的实例化

构造方法

工厂

静态工厂和实例工厂

***FactoryBean

Scope作用域

生命周期

Aware接口

***BeanPostProcessor接口

before和after之间的过程

注意

容器关闭

完整的生命周期的流程

注解

组件注册功能的注解

作用域

生命周期中的init和destroy方法

注入功能的注解

组件的注入

值的注入

注意事项

单元测试

引入依赖

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Spring框架

Spring框架

引入依赖

配置文件

注册组件

测试

取出组件的方式

维护多个组件之间的关系

核心接口

Bean的实例化

构造方法

工厂

静态工厂和实例工厂

***FactoryBean

Scope作用域

生命周期

Aware接口

***BeanPostProcessor接口

before和after之间的过程

注意

容器关闭

完整的生命周期的流程

**注解 **

组件注册功能的注解

作用域

生命周期中的init和destroy方法

注入功能的注解

组件的注入

值的注入

注意事项

单元测试

引入依赖

热门文章

最新文章

相关课程

相关电子书

相关实验场景

注解