Spring详解

最新推荐文章于 2024-08-01 22:00:59 发布
最新推荐文章于 2024-08-01 22:00:59 发布
阅读量736 收藏 2
点赞数
分类专栏： 系统架构 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/b2222505/article/details/78613353
版权

 

Bean的生命周期

 

0,调用BeanFactoryPostProcessor的postProcessBeanFactory方法
1,调用Bean的构造函数(或者工厂方法)实例化Bean.
2,对Bean的成员变量赋值.
3,如果Bean实现了BeanNameAware,调用Bean的setBeanName方法.
4,如果Bean实现了BeanFactoryAware,调用Bean的setBeanFactory方法.
5,如果Bean实现了ApplicationContextAware,调用Bean的setApplicationContext方法.
6,如果容器中配置了BeanPostProcessor,调用BeanPostProcessor的postProcessBeforeInitialization方法(如果有多个,调用每一个）
6,如果Bean实现了InitializingBean,调用Bean的afterPropertiesSet方法.
7,如果Bean配置了init-method方法,调用init-method配置的Bean方法.
8,如果容器中配置了BeanPostProcessor,调用BeanPostProcessor的postProcessAfterInitialization方法.(如果有多个,调用每一个）
9,Bean处于可以使用的状态.
10,Spring容器关闭.
11,如果Bean实现了DisposableBean,调用Bean的destroy方法.
12,如果Bean配置了destroy-method方法,调用destroy-method配置的Bean的方法.

 

 

 

Bean

 

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * 测试生命周期的Bean
 */
public class StudentBean implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware {
    private String name;
    private int age;

    private String beanName;//实现了BeanNameAware接口，Spring可以将BeanName注入该属性中
    private BeanFactory beanFactory;//实现了BeanFactory接口，Spring可将BeanFactory注入该属性中

    public StudentBean(){
        System.out.println("【Bean构造方法】学生类的无参构造方法");
    }

    @Override
    public String toString() {
        return "StudentBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", beanName='" + beanName + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("【set注入】注入学生的name属性");
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        System.out.println("【set注入】注入学生的age属性");
        this.age = age;
    }

    /**
     * 自己编写的初始化方法
     */
    public void myInit(){
        System.out.println("【init-method】调用init-method属性配置的初始化方法");
    }

    /**
     * 自己编写的销毁方法
     */
    public void myDestroy(){
        System.out.println("【destroy-method】调用destroy-method属性配置的销毁方法");
    }

    /**
     * BeanFactoryAware接口的方法
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware的setBeanFactory方法得到beanFactory引用");
    }

    /**
     * BeanNameAware接口的方法
     * @param name
     */
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("【BeanNameAware接口】调用BeanNameAware的setBeanName方法得到Bean的名称");
    }

    /**
     * InitializingBean接口的方法
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【InitializingBean接口】调用InitializingBean接口的afterPropertiesSet方法");
    }

    /**
     * DisposableBean接口的方法
     * @throws Exception
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("【DisposableBean接口】调用DisposableBean接口的destroy方法");
    }
}

 

 

 

BeanPostProcessor接口

 

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor(){
        System.out.println("【BeanPostProcessor接口】调用BeanPostProcessor的构造方法");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor接口】调用postProcessBeforeInitialization方法，这里可对"+beanName+"的属性进行更改。");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor接口】调用postProcessAfterInitialization方法，这里可对"+beanName+"的属性进行更改。");
        return bean;
    }
}

 

 

 

BeanFactoryPostProcessor接口

 

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor() {
        System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor实现类构造方法");
    }

    /**
     * 重写BeanFactoryPostProcessor接口的postProcessBeanFactory方法，可通过该方法对beanFactory进行设置
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("studentBean");
        beanDefinition.getPropertyValues().addPropertyValue("age", "21");
    }
}

 

 

 

Spring配置文件beans.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:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <!--配置Bean的后置处理器-->
    <bean id="beanPostProcessor" class="com.xxx.cyclelife.MyBeanPostProcessor">
    </bean>

    <!--配置BeanFactory的后置处理器-->
    <bean id="beanFactoryPostProcessor" class="com.xxx.cyclelife.MyBeanFactoryPostProcessor">
    </bean>

    <bean id="studentBean" class="com.xxx.cyclelife.StudentBean" init-method="myInit"
          destroy-method="myDestroy" scope="singleton">
        <property name="name" value="xxx"></property>
        <property name="age" value="21"></property>
    </bean>

</beans>

 

 

 

 

 

 

 

常用注解

@Autowire和@Resource

 

 

 

共同点：
均可标注在字段或属性的setter方法上。
都可以通过@Qualifier显式指定 autowired by qualifier name。


区别：
@Autowired是spring的注解，使用AutowiredAnnotationBeanPostProcessor处理依赖注入。
@Resource来自于JSR-250位于java.annotation包，使用CommonAnnotationBeanPostProcessor处理依赖注入。
@Autowired默认 autowired by type，如果失败，则退化为autowired by field name；
@Resource默认autowired by field name，如果失败，则退化为autowired by type。可以使用@Autowired + @Qualifier实现@Resource的效果。
@Autowired有个required属性，配置为false时如果没有找到对应的bean是不会抛异常的。@Resource没有该配置，找不到会抛异常。

 

 

 

@Component和@Service、@Repository、@Controller

 

 

 

使用@Component注解标识类会生成响应的bean，默认的名称（id）是小写开头的非限定类名。也可以指定名称：@Component(“hello”)，不推荐使用。

@Controller对应控制层的Bean，@Service对应的是业务逻辑层Bean，@Repository对应数据访问层也就是持久层的Bean。和@Component是等效的，区别在于后三个有具体的业务含义，分别对应web架构的3个分层。推荐使用后三者代替@Component，在spring未来的版本中，@Controller，@Service，@Repository会携带更多语义。并且便于开发和维护。

 

 

 

@Qualifier

 

当容器中存在同样类型的多个bean时，用@Qualifier注解指定注入Bean的名称 。

 

 

@ComponentScan

 

 

 

自动扫描包名下所有声明为Bean的类

 

 

 

@EnableAspectJAutoProxy 

 

 

 

开启Spring对AspectJ的支持

 

 

 

@Bean

 

 

 

注解在方法上，声明当前方法的返回值为一个Bean

 

 

 

@PostConstruct

 

 

 

在构造函数执行完后执行

 

 

 

@PreDestroy

 

 

 

在Bean销毁之前执行

 

 

 

AOP注解（链接git）

@Aspect  //声明为切面
@PointCut //切点，定义拦截规则
@After
@Before
@Around

 

 

@Conditional 

这个注解会检查条件，只有这个条件满足的时候，才会enable某些配置
标注在类上，声明配置类，相当于把该类作为spring的xml配置文件中的来使用。

 

@ConditionalOnClass
当classpath里面有一个或几个指定的类的时候才激活一个配置

@ConditionalOnMissingBean
当一个bean没有创建的时候，创建一个bean

@ConditionalOnBean
@ConditionalOnExpression
@ConditionalOnMissingClass
@ConditionalOnNotWebApplication
@ConditionalOnResource
@ConditionalOnWebApplication


 

@EnableXXX

 

使用@Import注解来做了一个简单的configuration import

@EnableTransactionManagement
启用了声明式的事务管理

@EnableWebMvc
启用Spring MVC

@EnableScheduling
初始化一个定时器。

@EnableConfigurationProperties
自动把一个POJO映射到一个Spring Boot配置文件（默认的是application.properties）里面的属性列表

 

 

 

@Import和@ImportResource

详情请看

 

全局句柄

package com.oppo.push.inbox.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Lazy(false)
@Component()
public class ApplicationContextHolder implements ApplicationContextAware {
    private final static Logger log = LoggerFactory.getLogger(ApplicationContextHolder.class);
    private ApplicationContextHolder(){}
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextHolder.applicationContext = applicationContext;
        log.info("spring applicationContext init");
    }

    public static ApplicationContext getApplicationContext() {
        if(applicationContext == null)
            throw new IllegalStateException("'applicationContext' property is null,ApplicationContextHolder not yet init.");
        return applicationContext;
    }
}

其他

https://www.cnblogs.com/liaojie970/p/8042686.html

https://www.cnblogs.com/duanxz/p/7493276.html

https://www.cnblogs.com/kungfupanda/p/7747004.html

 

 

未完待续

 

啊浪的博客
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring详解及使用
daniel_fei的博客
02-23 2691
Spring知识点 一、 专业术语 1. 侵入式设计 引入框架，对现有的类的结构有影响，即需要实现或继承某些特定类。如：Struts框架 2. 非侵入式设计 引入框架，对现有的类结构没有影响。如：Hibernate、Spring 3. 控制反转（IoC） 控制反转（Inversion on Control 、IoC）:把对象的创建交给外部容器完成。 4. 依赖注入（DI） 依
Spring内容讲解与介绍
11-17
Spring框架的核心技术是IOC和AOP（采用jdk和cglib动态代理实现的）
Spring（看这一篇就够了）
最新发布
m0_74436895的博客
08-01 1401
Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制反转）和AOP（面向切面）为思想内核，提供了控制层SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。Spring官网地址：https://spring.io/.\ Spring框架根据不同的功能被划分成了多个模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使
Spring全面详解
White-Camellia
12-07 3339
Spring是个Java企业级应用JavaEE(13种规范)的开源开发框架。Spring主要用来开发Java应用，是针对构建JavaEE平台的web应用。
spring详解
weixin_50098749的博客
03-22 3294
Spring(详解) 什么是spring? Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。 Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。 然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 目的：解决企业应用开发的复杂性 功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 范围：任何Java应用 它是一个容器框架，用来装ja
Java全栈课程之Spring详解
02-12
《Spring详解——Java全栈开发的关键》 Spring框架是Java企业级应用开发的基石，它以其灵活、高效和模块化的特性赢得了广大开发者的一致好评。本篇将深入探讨Spring的核心概念，包括IoC（Inversion of Control）...
Spring 详解
03-08
Spring IOC aop 原理详解
百知教育Spring详解笔记.rar
05-07
以下是对"百知教育Spring详解笔记"的详细解读。 1. **控制反转（IoC）**：Spring通过IoC容器管理对象的生命周期和依赖关系，使得开发者不再需要在代码中手动创建和管理对象，而是由容器负责。这样提高了代码的可...
spring详解教程
04-27
《Spring详解教程》 Spring框架是Java开发中最广泛使用的轻量级开源框架之一，它以其依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）为核心，极大地简化了企业级应用的...
【Sping】常见面试题总结
云祁QI
11-29 1865
1、Spring是什么? Spring是一个轻量级的IOC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置。 主要由以下几个模块组成： Spring Core：核心类库，提供IOC服务； Spring Context：提供框架式的Bean访问方...
Spring详解（一）------概述
IT可乐
09-02 317
　　本系列教程我们将对 Spring 进行详解的介绍，相信你在看完后一定能够有所收获。 1、什么是 Spring ? 　　Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企...
Spring详解（学习总结）
热门推荐
互联网底层民工的博客
07-11 3万+
Spring是一个分层的java SE/EE full-stack（一站式）轻量级开源框架，以IOC（控制反转）和AOP（面向切面编程）为内核。 在java三层架构当中分别提供了相应的技术： 表现层（web层）：SpringMVC框架 业务层（service层）：Bean管理（IOC容器） 持久层（dao层）：jdbcTemplate模板对象以及提供了ORM模块整合其他优秀的持久层技术。 方便解耦，简化开发：Spring就是一个工厂，可以管理所有对象的创建和依赖关系维护，交给Spring管理。
java Spring详解
05-20
Spring 是一个开源的企业级应用程序框架，它是轻量级的、非侵入式的、面向切面的、基于 POJO 的框架，它可以用来构建任何类型的 Java 应用程序。Spring 的主要目标是提供一个全面的、一致的编程模型，用于构建现代化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值