Spring 框架容器管理注解和生命周期

Spring 注解

在 Spring 框架中，大量的注解是由 Spring 容器（而不是虚拟机）进行处理和解析的。Spring 框架使用了反射和自定义的处理机制来解析注解，并根据注解的定义执行相应的逻辑。

Spring 框架中的注解主要用于配置和控制应用程序的行为，例如声明 Bean、依赖注入、AOP 等。以下是一些常用的 Spring 注解及其作用：

@Component：用于标记一个类为 Spring 组件，会被 Spring 自动扫描并创建实例。
@Autowired：用于自动注入依赖对象。
@RequestMapping：用于映射 HTTP 请求到处理方法。
@Transactional：用于声明事务管理。
@Aspect、@Before、@After 等：用于声明切面和切点，实现 AOP 功能。

当使用了这些注解时，Spring 容器会在应用程序启动时扫描所配置的包，并解析这些注解。它会通过反射机制获取注解信息，并根据注解的定义执行相应的逻辑，例如创建 Bean 实例、自动注入依赖、生成代理对象等。

Spring 框架还提供了一些工具类和接口，用于处理和解析注解，例如 AnnotationUtils、AnnotatedElementUtils、AnnotationConfigApplicationContext 等。这些工具和接口可以让开发人员更方便地处理和访问注解信息。

需要注意的是，虽然 Spring 框架在运行时使用了反射来处理注解，但这并不是虚拟机自动处理的。相反，Spring 框架提供了一套机制，用于解释和执行这些注解，并在应用程序运行时根据注解的定义来完成相应的功能。

Spring 容器

在 Spring 框架中，Spring 容器是一个负责创建、管理和组织应用程序中各个组件（Bean）的容器。它提供了一种便捷的方式来管理对象的生命周期、依赖注入和解析、AOP 等功能。

Spring 容器主要有两种类型：BeanFactory 和 ApplicationContext。

BeanFactory：这是 Spring 容器的基本接口，定义了最简单的容器功能。它提供了对 Bean 的创建、获取、销毁等基本操作。示例代码如下：

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;public class MainApp {public static void main(String[] args) {BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));MyBean myBean = (MyBean) factory.getBean("myBean");myBean.doSomething();}
}

ApplicationContext：这是 BeanFactory 接口的扩展，提供了更多的高级功能。它是 Spring 容器的完整实现，支持国际化、资源加载、事件发布等特性。示例代码如下：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class MainApp {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");MyBean myBean = (MyBean) context.getBean("myBean");myBean.doSomething();}
}

在这两个示例中，spring-config.xml 是一个 XML 配置文件，用于定义 Bean 的配置和依赖关系。在实际应用中，可以使用不同的配置方式，如注解或 Java Config，来定义 Bean。

Spring 容器会读取配置文件并根据配置信息创建相应的 Bean 对象。通过调用容器的 getBean() 方法，可以获取到已经创建的 Bean 实例，并使用其提供的功能。

总结来说，Spring 容器是一个负责管理和组织应用程序中各个组件的容器，它可以根据配置信息创建、初始化和管理对象。通过使用 Spring 容器，可以实现依赖注入、AOP、事务管理等功能，使开发人员可以更加专注于业务逻辑的实现。

Spring 容器中 BeanFactory

public class BeanFactory implements ObjectFactory {private static final StringManager sm = StringManager.getManager(BeanFactory.class);private final Log log = LogFactory.getLog(BeanFactory.class); // Not static/*** Create a new Bean instance.** @param obj The reference object describing the Bean*/@Overridepublic Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?,?> environment)throws NamingException {if (obj instanceof ResourceRef) {try {Reference ref = (Reference) obj;String beanClassName = ref.getClassName();Class<?> beanClass = null;ClassLoader tcl = Thread.currentThread().getContextClassLoader();try {if (tcl != null) {beanClass = tcl.loadClass(beanClassName);} else {beanClass = Class.forName(beanClassName);}} catch(ClassNotFoundException cnfe) {NamingException ne = new NamingException(sm.getString("beanFactory.classNotFound", beanClassName));ne.initCause(cnfe);throw ne;}BeanInfo bi = Introspector.getBeanInfo(beanClass);PropertyDescriptor[] pda = bi.getPropertyDescriptors();Object bean = beanClass.getConstructor().newInstance();// Look for the removed forceString optionRefAddr ra = ref.get("forceString");if (ra != null) {log.warn(sm.getString("beanFactory.noForceString"));}Enumeration<RefAddr> e = ref.getAll();String value;while (e.hasMoreElements()) {ra = e.nextElement();String propName = ra.getType();if (propName.equals(Constants.FACTORY) ||propName.equals("scope") || propName.equals("auth") ||propName.equals("forceString") ||propName.equals("singleton")) {continue;}value = (String)ra.getContent();Object[] valueArray = new Object[1];int i = 0;for (i = 0; i < pda.length; i++) {if (pda[i].getName().equals(propName)) {Class<?> propType = pda[i].getPropertyType();Method setProp = pda[i].getWriteMethod();if (propType.equals(String.class)) {valueArray[0] = value;} else if (propType.equals(Character.class) || propType.equals(char.class)) {valueArray[0] = Character.valueOf(value.charAt(0));} else if (propType.equals(Byte.class) || propType.equals(byte.class)) {valueArray[0] = Byte.valueOf(value);} else if (propType.equals(Short.class) || propType.equals(short.class)) {valueArray[0] = Short.valueOf(value);} else if (propType.equals(Integer.class) || propType.equals(int.class)) {valueArray[0] = Integer.valueOf(value);} else if (propType.equals(Long.class) || propType.equals(long.class)) {valueArray[0] = Long.valueOf(value);} else if (propType.equals(Float.class) || propType.equals(float.class)) {valueArray[0] = Float.valueOf(value);} else if (propType.equals(Double.class) || propType.equals(double.class)) {valueArray[0] = Double.valueOf(value);} else if (propType.equals(Boolean.class) || propType.equals(boolean.class)) {valueArray[0] = Boolean.valueOf(value);} else if (setProp != null) {// This is a Tomcat specific extension and is not part of the// Java Bean specification.String setterName = setProp.getName();try {setProp = bean.getClass().getMethod(setterName, String.class);valueArray[0] = value;} catch (NoSuchMethodException nsme) {throw new NamingException(sm.getString("beanFactory.noStringConversion", propName, propType.getName()));}} else {throw new NamingException(sm.getString("beanFactory.noStringConversion", propName, propType.getName()));}if (setProp != null) {setProp.invoke(bean, valueArray);} else {throw new NamingException(sm.getString("beanFactory.readOnlyProperty", propName));}break;}}if (i == pda.length) {throw new NamingException(sm.getString("beanFactory.noSetMethod", propName));}}return bean;} catch (java.beans.IntrospectionException ie) {NamingException ne = new NamingException(ie.getMessage());ne.setRootCause(ie);throw ne;} catch (java.lang.ReflectiveOperationException e) {Throwable cause = e.getCause();if (cause instanceof ThreadDeath) {throw (ThreadDeath) cause;}if (cause instanceof VirtualMachineError) {throw (VirtualMachineError) cause;}NamingException ne = new NamingException(e.getMessage());ne.setRootCause(e);throw ne;}} else {return null;}}
}

Spring 中注解的处理机制

在 Spring 框架中，注解的处理机制是通过反射和基于注解的配置来实现的。Spring 可以通过扫描类路径或者指定的包路径，自动识别和处理注解，从而实现一些特定的功能。

以下是 Spring 中常见注解的处理机制：

组件扫描：Spring 提供了 @ComponentScan 注解用于指定要扫描的包路径，从而自动发现带有特定注解的类。在启动应用时，Spring 将扫描指定包路径下的所有类，并将带有 @Component 及其衍生注解（如 @Service、@Repository、@Controller）的类注册为 Bean。
Bean 定义：通过注解可以方便地定义 Bean，例如 @Component、@Service、@Repository、@Controller 等。这些注解告诉 Spring 在扫描到对应的类时将其注册为 Bean。
依赖注入：Spring 提供了 @Autowired 注解用于自动装配 Bean，它可以标记在字段、构造函数或方法上，Spring 将根据类型进行匹配并将依赖的 Bean 自动注入到对应的位置。
切面编程：通过注解可以方便地定义切面和通知，例如 @Aspect、@Before、@After、@Around 等。这些注解可以让开发者在不修改原有业务代码的情况下，方便地实现横切关注点的功能。
事务管理：使用 @Transactional 注解可以简化事务的管理，通过在方法或类上添加该注解，在满足条件的情况下 Spring 将自动为方法添加事务支持。