spring---bean的一生

最新推荐文章于 2024-11-06 09:23:18 发布
最新推荐文章于 2024-11-06 09:23:18 发布
阅读量119 收藏
点赞数
分类专栏： spring原理 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ranxiaochuan1994/article/details/105249291
版权

bean的生命周期详解


  beanFactory容器启动之后，首先解析配置文件，生成并注册beanDefinition对象。beanDefinition包含了bean的实例化阶段所必需的信息。只有通过getBean方法来获取某个对象的实例使，容器才实例化这个对象。这一点更ApplicationContext容器不同，在getBean方法调用之前就将所有的类实例化。但是这两个容器都有一个特点，只要实例化一个对象，并且这个对象是单例模式，那么容器就有指向这个对象的引用，该对象的生命周期就由容器管理。接下来将详细介绍bean的生命周期的各个阶段。

Bean实例化过程图

在这里插入图片描述

实例化bean对象

  容器实例化bean是采用“策略模式”来决定采用何种方式来初始化bean实例。可以通过反射或CGLIB动态字节码来生成初始化相应bean实例或则动态生成其子类。InstantiationStrategy接口定义了实例化策略的抽象接口。其子类SimpleInstantiationStrategy实现了简单的对象实例化功能，可以通过反射来支持对象实例化，但不支持方法注入方式。CglibSubclassInstantiationStrategy继承了SimpleInstantiationStrategy类的以反射方式来实例化对象，并且使用cglib动态字节码生成技术，动态生成某个类的子类，从而支持方法注入方式。实例化之后，并不是直接返回bean对象，而是返回一个BeanWrapper对象，该对象封装了bean实例。之所以封装成BeanWrapper对象，是方便第二部的为对象赋值的操作。
  InstantiationStrategy接口方法全是对象实例化方法，入参都含有BeanDefinition对象。可以看出，spring容器实例化对象都要使用BeanDefinition对象。
  如果对方法注入不是很熟悉，请点击这里

public interface InstantiationStrategy {
    Object instantiate(RootBeanDefinition var1, String var2, BeanFactory var3) throws BeansException;

    Object instantiate(RootBeanDefinition var1, String var2, BeanFactory var3, Constructor<?> var4, Object... var5) throws BeansException;

    Object instantiate(RootBeanDefinition var1, String var2, BeanFactory var3, Object var4, Method var5, Object... var6) throws BeansException;
}

  InstantiationStrategy接口实现图：
在这里插入图片描述
  SimpleInstantiationStrategy类的instantiate方法解析：

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
        if (bd.getMethodOverrides().isEmpty()) {
            Constructor constructorToUse;
            synchronized(bd.constructorArgumentLock) {
            	//获取配置文件中设置的构造器方法
                constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                	//获取beanDefinition对象中的类对象
                    final Class<?> clazz = bd.getBeanClass();
                    //如果类对象是接口则抛出异常
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }
				
                    try {
                        if (System.getSecurityManager() != null) {
                            constructorToUse = (Constructor)AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                                public Constructor<?> run() throws Exception {
                                	//调用class对象的无参构造器，使用java反射机制实例化对象
                                    return clazz.getDeclaredConstructor((Class[])null);
                                }
                            });
                        } else {
                            constructorToUse = clazz.getDeclaredConstructor((Class[])null);
                        }

                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    } catch (Throwable var9) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", var9);
                    }
                }
            }
			/调用class对象的无参构造器，使用java反射机制实例化对象
            return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
        } else {
        	//使用方法注入方式注入属性，在SimpleInstantiationStrategy类中调用此方法会抛出异常，SimpleInstantiationStrategy不支持方法注入方式
            return this.instantiateWithMethodInjection(bd, beanName, owner);
        }
    }

  CglibSubclassCreator是CglibSubclassingInstantiationStrategy的内部类，其功能是创间bean实例，支持方法注入

    private static class CglibSubclassCreator {
        private static final Class<?>[] CALLBACK_TYPES = new Class[]{NoOp.class, CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor.class, CglibSubclassingInstantiationStrategy.ReplaceOverrideMethodInterceptor.class};
        private final RootBeanDefinition beanDefinition;
        private final BeanFactory owner;

        CglibSubclassCreator(RootBeanDefinition beanDefinition, BeanFactory owner) {
            this.beanDefinition = beanDefinition;
            this.owner = owner;
        }

        public Object instantiate(Constructor<?> ctor, Object... args) {
            Class<?> subclass = this.createEnhancedSubclass(this.beanDefinition);
            Object instance;
            if (ctor == null) {
            	//如果没传构造器，则使用子类的无参构造器创建实例
                instance = BeanUtils.instantiateClass(subclass);
            } else {
                try {
                	//根据传入的构造器，查找子类的对应构造器
                    Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
                    //使用子类有参构造器，通过反射创建实例
                    instance = enhancedSubclassConstructor.newInstance(args);
                } catch (Exception var6) {
                    throw new BeanInstantiationException(this.beanDefinition.getBeanClass(), "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", var6);
                }
            }

            Factory factory = (Factory)instance;
            //设置回调
            factory.setCallbacks(new Callback[]{NoOp.INSTANCE, new CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor(this.beanDefinition, this.owner), new CglibSubclassingInstantiationStrategy.ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
            return instance;
        }
		//创建增强代理类
        private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(beanDefinition.getBeanClass());
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            if (this.owner instanceof ConfigurableBeanFactory) {
                ClassLoader cl = ((ConfigurableBeanFactory)this.owner).getBeanClassLoader();
                enhancer.setStrategy(new CglibSubclassingInstantiationStrategy.ClassLoaderAwareGeneratorStrategy(cl));
            }

            enhancer.setCallbackFilter(new CglibSubclassingInstantiationStrategy.MethodOverrideCallbackFilter(beanDefinition));
            enhancer.setCallbackTypes(CALLBACK_TYPES);
            return enhancer.createClass();
        }
    }

属性设置

  初始化bean之后，返回的是bean的包装对象BeanWrapperImpl对象，BeanWrapperImpl类间接实现了PropertyAccessor接口和TypeConverter接口,其中PropertyAccessor接口是用来为对象设置属性和获取属性值得。

public interface PropertyAccessor {
    String NESTED_PROPERTY_SEPARATOR = ".";
    char NESTED_PROPERTY_SEPARATOR_CHAR = '.';
    String PROPERTY_KEY_PREFIX = "[";
    char PROPERTY_KEY_PREFIX_CHAR = '[';
    String PROPERTY_KEY_SUFFIX = "]";
    char PROPERTY_KEY_SUFFIX_CHAR = ']';

    boolean isReadableProperty(String var1);

    boolean isWritableProperty(String var1);

    Class<?> getPropertyType(String var1) throws BeansException;

    TypeDescriptor getPropertyTypeDescriptor(String var1) throws BeansException;

    Object getPropertyValue(String var1) throws BeansException;

    void setPropertyValue(String var1, Object var2) throws BeansException;

    void setPropertyValue(PropertyValue var1) throws BeansException;

    void setPropertyValues(Map<?, ?> var1) throws BeansException;

    void setPropertyValues(PropertyValues var1) throws BeansException;

    void setPropertyValues(PropertyValues var1, boolean var2) throws BeansException;

    void setPropertyValues(PropertyValues var1, boolean var2, boolean var3) throws BeansException;
}

使用接口的复制方法，只要指定属性名称和属性值，便可以为接口中的包装对象设置值，因为不用j直接使用java 反射api就可以简单实现。大大简化了属性赋值操作。

检测Aware接口实现类

  当对象实例化后，并完成相关属性设置，spring容器开始检测该bean是否实现了Aware接口，，如果实现了Aware接口，则将接口规定的依赖注入给当前对象。Aware接口为如下几个：

  1. BeanNameAware:会将对象实例对应的bean定义对应的beanName设置到当前对象中去。
  2. BeanClassLoaderAware:将加载当前bean的classLoader设置到对象中去。
  3. BeanFactoryAware：beanFactory容器会将自身设置到当前对象中去
  4. ResourceLoaderAware:ApplicationContext会将自身设置到当前对象中去。
  5. ApplicationEventPublisherAware:会将ApplicationEventPublisher设置到当前对象中去（ApplicationContext实现了ApplicationEventPublisher接口，因此这时候ApplicatonContext容器会将自身设置到当前对象中去）。
  6. MessageSourceAware:将MessageSource对象设置到当前实例中去（ApplicationContext实现了MessageSource接口，因此这时候ApplicatonContext容器会将自身设置到当前对象中去）
  7. ApplicationContextAware:会将自身设置到当前对象中去。
      上面的这些规则读起来十分绕缺口，简单来说，如果你定义了一个类，在对象的使用过程中你会用到BeanFactory对象，那么你就只需要实现BeanFactoryAware接口，同时在定义的类中增加一个BeanFactory属性。由于你实现了BeanFactoryAware接口，因此自定义类中也会有一个接口方法setBeanFactory(BeanFactory var1),在该方法中，你字需要将传入的参数赋给自定义类的对应属性即可。自定义类实例化完成后，容器会自动调用该方法，完成属性的赋值工作。代码如下：
public class People implements BeanFactoryAware {
    private BeanFactory beanFactory;
    //容器会自动调用该方法，完成赋值工作
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
}

BeanPostProcessor接口

  讲到BeanPostProcessor接口，首先要和BeanFactoryPostProcessor接口区分开来，想了解BeanFactoryPostProcessor接口的朋友请点击这里，BeanPostProcessor接口方法调用时在对象实例化之后，而BeanFactoryPostProcessor接口方法调用是在容器启动阶段，对所有满足条件的beanDefinition做操作，此时bean还没有实例化。BeanPostProcessor接口又两个接口方法，分别为：postProcessBeforeInitialization（又称为前置处理方法），postProcessAfterInitialization（又称为后置处理方法）。两个方法都将bean实例的引用当做参数传入。

public interface BeanPostProcessor {
	//前置处理方法
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;
	//后置处理方法
    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
}

  BeanPostProcessor接口通常用来处理标记接口实现类或则为当前接口实现代理。上面讲的Aware接口处理实际上就是使用BeanPostProcessor方式进行处理的。当容器中的对象走到BeanPostProcessor的前置处理器这一步时，ApplicationContext容器就会检测之前注册到容器中的ApplicationContextAwareProcessor类（此类是BeanPostProcessor接口的实现类），然后调用前置处理方法，检测并设置Aware相关依赖。

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;

		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
						bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
						bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
					//检测Aware接口并设置相关依赖
					invokeAwareInterfaces(bean);
					return null;
				}
			}, acc);
		}
		else {
			//检测Aware接口并设置相关依赖
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

private void invokeAwareInterfaces(Object bean) {
		//如果当前实例实现Aware接口
		if (bean instanceof Aware) {
			//如果实现
			if (bean instanceof EnvironmentAware) {
				//为当前实例设置environment依赖
				((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
			}
			//如果实现EmbeddedValueResolverAware
			if (bean instanceof EmbeddedValueResolverAware) {
				//为当前实例设置embeddedValueResolver依赖
				((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
			}
			//如果实现ResourceLoaderAware
			if (bean instanceof ResourceLoaderAware) {
				//为当前实例设置applicationContext依赖
				((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
			}
			//如果实现ApplicationEventPublisherAware
			if (bean instanceof ApplicationEventPublisherAware) {
				//为当前实例设置applicationContext依赖
				((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
			}
			//如果实现MessageSourceAware
			if (bean instanceof MessageSourceAware) {
				//为当前实例设置applicationContext依赖
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
			}
			//如果实现ApplicationContextAware
			if (bean instanceof ApplicationContextAware) {
				//为当前实例设置applicationContext依赖
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}

  BeanPostProcessor是spring为开发者提供的一个非常有用的拓展点，我们可以通过实现BeanPostProcessor接口，实现接口方法，从而对满足条件的bean实例进行修改或则替换，比如对当前对象进行增强操作。创建好自定义类之后，将该类注册到容器中即可。

检测是否为InitializingBean实现类

  这里手下说明一下，实现InitializingBean接口和在配置文件中配置init-method属性的作用是一样的，两者都是在执行完Aware接口处理之后，会调用InitializingBean实现类的afterPropertySet方法或者执行init-method指定的方法。但是通过实现InitializingBean接口的方式具有侵入性，因此在实际开发中，我们更倾向于使用init-method配置的方式。
  spring.xml配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="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
       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <bean id="user" class="springBeanTest.User" init-method="init">
    </bean>
</beans>

  User类：

public class User {
    private String username;
    private String password;

    public void init(){
        this.username = "ranxiaochuan";
        this.password = "123";
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

  测试类

public class LifeCycleTest {
    @Test
    public void test1(){
        //创建bean的工厂类
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        //创建一个xml文件的reader类，将bean工厂传入reader中
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((BeanDefinitionRegistry) beanFactory);
        //加载xml未配置文件，并将配置文件解析成BeanDefinition对象保存在工厂类中
        reader.loadBeanDefinitions("classpath:/spring.xml");
        User user = (User) beanFactory.getBean("user");
        System.out.println(user.getPassword());
        System.out.println(user.getUsername());
    }
}

  测试结果：
在这里插入图片描述

BeanPostProcessor后置处理

  BeanPostProcessor后置处理跟BeanPostProcessor前置处理思路一样，只是调用时间有差别。这里就不再赘述。

检查是否实现DisposableBean接口或则是否配置destroy方法

  实现DisposableBean接口和配置destroy方法的作用是一样的，前者有侵入性，后者没有。他们的作用都是在对象销毁前做一些清理工作，比如说对与数据库连接对象，在销毁之前应该关闭数据库连接。这里需要主要一点，无论是BeanFactory容器还是ApplicationContext容器，如果要调用销毁方法，都必须在主程序执行结束之前显示的调用容器的销毁方法。BeanFactory容器调用distroySingletons()方法；ApplicationContext容器调用registerShutDownHook（）方法。到此，bean的生命周期就结束了。

ranxiaochuan1994
关注
专栏目录
Spring - Bean的生命周期
Andy_Health的博客
07-15 124
Bean的一生过程 因为当对应某个bean定义的getBean()方法第一次被调用时，不管是显示的还是隐式的，Bean实例化阶段才会被触发，第二次被调用则会直接返回容器缓存的第一次实例化完的对象实例(因为默认是singleton单例，当然，这里的情况prototype类型的bean除外) 可以简述为以下九步 实例化bean对象(通过构造方法或者工厂方法) 设置对象属性(setter等)（依赖注入） 如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Be
Springbean生命周期详解
qq_64169170的博客
02-21 1万+
在传统的java应用中，JavaBean的生命周期一般都是浅化理解，就是在在Java中使用关键字new把Bean进行实例化，然后Bean就可以使用了，一旦不使用了，Java会自动进行垃圾回收。 如果是在springBean里面，Bean的生命周期就显得非常复杂，我把它详细了解了一下，分为十个步骤： Bean的实例化：spring启动后，会查找和加载需要被spring管理的Bean，并且实例化。 Bean属性注入：Bean被实例化后对将Bean的引入和值注入到Bean的属性中。 调用BeanNameA
bean的一生----Spring容器启动
ia的博客
11-09 296
1.我这里通过AnnotationConfigApplicationContext来new一个容器对象; 可以看到构造方法实现了三个方法： this(); this.register(componentClasses); this.refresh(); 第一个：this();调用默认构造方法会调用父类的默认构造方法 这里父类构造器通过DefaultListableBeanFactory来创建一个beanFactory对象 进去DefaultListableBeanFactory看看里面有什么 其
Spring源码--Bean生命周期
a18792721831的博客
08-29 194
Spring源码--Bean生命周期BeanNameAwareBeanFactoryAwareApplicationContextAwarepostProcessBeforeInitialization@PostConstructafterPropertiesSetpostProcessAfterInitialization@PreDestoryDisposableBean实例 先来一张bean的生命周期图 github地址： https://github.com/a18792721831/studySp
简单模拟实现Spring-IoC
wexin_mylove的博客
06-18 381
Spring框架的核心内容中，主要有两个功能：IoC和AOP。IoC又称为：控制反转，或者叫“自动注入”，而AOP则称为“面向切面编程”方案，或者称为：非侵入式逻辑更改/扩展。IoC的控制反转 中所谓的反转是指：非反转情况下，类的对象应该由代码自身实现实例化，而控制反转意味着，类的对象不是由代码本身完成实例化的，而是由某个“外在”系统实现实例化。本文是对IoC的一个简单实现。 这是由代码自身实现对象实例化。那么，IoC是使用“配置、自动注入”这两个配套手段实现对对象的实例化过程，即DI。代码中不会出现.
Spring的Bean加载流程
热门推荐
张维鹏的博客
02-22 7万+
Spring IOC容器就像是一个生产产品的流水线上的机器，Spring创建出来的Bean就好像是流水线的终点生产出来的一个个精美绝伦的产品。既然是机器，总要先启动，Spring也不例外。因此Bean的加载流程总体上来说可以分为两个阶段： 容器启动阶段 Bean创建阶段 一、容器启动阶段： 容器的启动阶段做了很多的预热工作，为后面Bean的实例化做好了充分的准备，我们首先看一下容器的启动阶段都做了哪些预热工作。 1、配置元信息： Spring IOC容器将对象实例的创建与对象实例的使用分离，当业务
深入Spring原理-2.Bean的生命周期
爱吃知识的土豆倪的博客
10-20 339
Spring IOC 中的Bean生命周期大致分为四个阶段：实例化、属性赋值、初始化、销毁，如下图所示：其实核心的阶段就是这些了，但是每个核心的阶段里面又有很细致的划分。
单独使用Spring-data-jap
树欲静而风不止
08-24 614
一、引入依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> <version>2.1.5.RELEASE</version> </dependency> .
Spring的Bean创建过程
Yuan_Su_的博客
04-25 2599
spring将内部管理的诸多对象称为一个个bean，而这些bean的创建流程大致分为两个大阶段： 下面本人将从上述两个阶段来阐述bean的完整创建过程。 在对象进行创建之前，spring容器需要了解所创建的对象的信息，才能在后续阶段根据了解的信息创建bean对象。这些信息即是实际工作中我们为对象所写的配置信息，它们一般以xml文件、properties文件和注解的形式存在于我们的项目之中。 一个以xml文件为存储形式的bean配置文件如下： 因此，
spring bean生命周期管理
毅本无言的成长之路
02-22 751
spring bean生命周期，spring框架老生常谈的话题，也是spring的基础知识。借此篇文章，结合spring框架部分源码，对spring针对bean的生命周期管理进行一个总结，加深记忆。 1. 概述 1.1 何为bean 在讲解bean的周期之前，我们先了解下什么是bean。自我们接触java开始，bean就无处不在。那么bean是什么？这里有两种解释，一种是狭义的，一种是广义的。在解释前，先简单介绍下bean的历史背景。 1.1.1 bean的来源与发展 在java诞生后不久，开发者为了让.
搞懂Spring Bean的一生，这篇文章就够了
GD_YuZhe的博客
07-30 527
基本概念 「Spring是一个IOC容器」 当我们不用Spring进行开发时，我们需要在代码中设置对象的依赖关系。当我们用了Spring之后，由Spring来管理这种依赖关系，当我们想使用对象时，直接从Spring容器中获取即可 「BeanDefinition」 在Spring中对象被叫做Bean，因为Spring Bean在Java类的基础上增加了很多概念，比如scope（作用域），isLazyInit（是否延迟初始化），isSingleton（是否单例），此时Java类不能完整的描述，所以需要新
一文详解Spring Bean生命周期
2301_76607156的博客
04-26 648
之前我们在总结Spring扩展点：后置处理器时谈到了SpringBean的生命周期和其对Spring框架原理理解的重要性，所以接下来我们就来分析一下Bean生命周期的整体流程。首先Bean就是一些Java对象，只不过这些Bean不是我们主动newBean的实例化(Instantiation)
Xxl-Job Spring Boot 版本更新
03-11 1431
https://www.jianshu.com/p/665213b3e2a9 随着业务的开发，使用的Spring Boot的版本比较新，有时需要跑一些定时任务，然后搭建了一个xxl-job的服务。 但是xxl-job自身的Spring Boot的版本比较小，现需要更新。 xxl-job Spring Boot 版本 更新 更新pom.xml # xxl-job pom.xml #...
SpringMVC入门详解
ning的博客
11-02 841
SpringMVC是一个基于Java的实现了MVC设计模式的Web框架，它通过将Web层进行模块化，使得Web应用程序的开发变得更加灵活和可维护。简化开发：通过注解的方式简化了配置，减少了代码量。强大的集成能力：可以很容易地与其他Spring模块集成。灵活的配置：支持零配置启动，也支持通过XML或Java配置进行详细配置。可重用性高：可以轻松地将一个项目中的代码重用到另一个项目中。
SpEL（Spring Expression Language）入门指南
kersixy的博客
11-05 679
SpEL（Spring Expression Language）是 Spring 框架提供的一个强大的表达式语言，用于在运行时查询和操作对象图。它类似于 JSP EL（JavaServer Pages Expression Language）和 OGNL（Object-Graph Navigation Language），但在功能上更为丰富和强大。
Spring常用过滤器（Filter）-ExceptionTranslationFilter
Liang的博客
11-04 1067
1.2.1 当请求经过Spring Security过滤器链时，如果某个过滤器抛出了异常（如AuthenticationException或AccessDeniedException），则ExceptionTranslationFilter会捕获这些异常，并根据异常的类型进行不同的处理。1.1.1 ExceptionTranslationFilter的主要功能是将Spring Security过滤器链中出现的特定异常（如认证异常和访问拒绝异常）转换为合适的HTTP响应或重定向操作。
# SpringMVC学习
11-04 958
SpringMVC 是 Spring 框架的一部分，专门用于构建 Web 应用程序。它遵循 MVC（Model-View-Controller）设计模式，通过一系列组件和机制实现了请求的接收、处理和响应。
Spring中@Autowired@Resource和@Inject注解区别
最新发布
2401_87333857的博客
11-06 380
同时，它默认是采用byType装配，当指定了1SR-330规范中的@Named注解之后，变成byName装配。它也可以出现在方法上，构造函数上和字段上但是需要注意的是:因为IRE无法决定构造方法注入的优先级，所以规范中规定类中只能有一个构造方法带@Inject注解。@Autowired:来源于spring框架自身默认是byType自动装配，当配合了@Qualifier注解之后，在没有指定name属性时是byType自动装配，当指定了name属性之后，采用byName方式自动装配。
使用Maven配置Spring-MVC框架详解
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/" /> </bean> <!-- 开启注解驱动的Spring MVC功能 --> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值