Spring 笔记

Java

Spring 简介

Spring 框架的七大模块：

• Spring Core：Spring 核心包。
• Spring Context：Spring IoC。
• Spring AOP：AOP 面向切面编程。
• Spring Web：与 Web 框架相关的包。
• Spring Web MVC：Spring MVC 相关的包。
• Spring JDBC：JDBC 模板相关的 API（DAO）。
• Spring ORM：ORM 框架相关的包（如 Hibernate）。

Spring Web 包是用来与其它 Web 框架集成用的，如 Struts2；而 Spring Web MVC 包是 Spring 提供的一个 MVC 框架，别搞混了，使用 Spring MVC 只需导入 spring-webmvc。

Spring 最核心的两个概念就是 IoC 和 AOP，IoC 是控制反转的英文缩写，AOP 是面向切面编程的英文缩写。

最基本的 spring 应用程序需要导入的包为：spring-core、spring-context。建议使用 maven 等自动构建工具来管理你的项目，因为这些自动构建工具通常都自带完善的 java 依赖包解决方案，本文使用 maven。

更新：对于基本的 spring 应用程序（IoC 容器），只需引入 spring-context 依赖就行，因为 spring-context 依赖于 spring-core，所以不需要显式引入 spring-core。

• 如果需要使用 IoC 容器，则添加：spring-context
• 如果需要使用 AOP 编程，则添加：spring-aop
• 如果需要使用 MVC 框架，则添加：spring-webmvc

Hello World

编辑 pom.xml，引入 spring-core 和 spring-context 依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.zfl9</groupId>
  <artifactId>JavaSE_HelloWorld</artifactId>
  <version>1.0-SNAPSHOT</version>
  <properties>
    <maven.test.skip>true</maven.test.skip>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>4.3.20.RELEASE</spring.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
  </dependencies>
</project>

创建 HelloWorld.java 类（Bean）：

package com.zfl9;
public class HelloWorld {
    private String message;
    public HelloWorld() {
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    @Override
    public String toString() {
        return String.format("message: %s", this.message);
    }
}

HelloWorld 类是一个标准的 Java Bean（或者说 POJO），即无参构造函数、私有属性的 getter 与 setter 方法。但因为 HelloWorld 类并没有实现序列化接口，所以我更喜欢称它为 POJO（即：普通 Java 类）。

创建 MainApp.java 类（运行的主类）：

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld helloworld = (HelloWorld) context.getBean("helloworld");
        System.out.println(helloworld);
    }
}

MainApp 类是一个 Main 可运行类，ApplicationContext 是一个 bean 容器（也就是 IoC 容器，其实你完全可以将 IoC 容器理解为一个 Map 对象，key 就是 bean 对象的 ID，value 就是 bean 对象的引用）。ApplicationContext 是一个借口，用 Spring 里面的术语叫做 Bean 容器/工厂，而 ClassPathXmlApplicationContext 是 ApplicationContext 接口的一个实现类，构造参数 beans.xml 表示 IoC 容器的配置文件名（很容易知道，beans.xml 应该能够在应用程序的 CLASSPATH 路径中找到）。

当我们调用 context 的 getBean 方法时，需要提供 bean 对象对应的 ID（见 beans.xml 文件内容），调用后，context 内部会返回对应的 bean 对象的引用给我们（返回的类型为 Object），需进行强制类型转换。

beans.xml 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="helloworld" class="com.zfl9.HelloWorld">
    <property name="message" value="Hello, Spring!"/>
  </bean>
</beans>

根元素为 beans，主要元素为 bean，bean 元素有两个基本属性：id 和 class，id 为 bean 对象的所属 ID，class 为 bean 对象的所属类名（全限定类名），当 Spring 实例化 bean 对象时，会执行类似 Object obj = new com.zfl9.HelloWorld() 的语句，即调用对应类的无参构造函数，这也是为什么我们的 bean 类需要一个无参构造函数（好吧，其实也不是必须，但是通常是这样的，毕竟 spring 允许我们传递构造参数给 bean 类）。而 bean 元素中的 property 元素则对应 setter 方法，比如上面的配置，就是调用对应的 setMessage() 方法，将 value 值传递给 bean 实例。

运行我们的 hello world 程序，将得到如下输出：

message: Hello, Spring!

IoC 容器

Spring 容器是 Spring Framework 的核心。容器将创建对象，将它们连接在一起，配置它们，并管理从创建到销毁的整个生命周期。Spring 容器使用 DI 来管理组成应用程序的组件。这些对象称为 Spring Beans。容器通过读取提供的配置元数据获取有关要实例化，配置和组装的对象的指令。配置元数据可以由 XML，Java 注释或 Java 代码表示。

Spring 提供两种常用的 Bean 容器：

• Spring BeanFactory Container：最基本的 Bean 容器，提供了最简单的 IoC 支持。
• Spring ApplicationContext Container：在 BeanFactory 的基础上添加了更多的功能。

我们上面的 HelloWorld 程序用的就是第二种，通常我们也是使用第二种容器，因为他提供许多有用的功能，但是也并不是说第一种 BeanFactory 就一无是处了，在资源有限的条件下，BeanFactory 的速度更快。注意，ApplicationContext 属于 spring-context 包，而 BeanFactory 属于 spring-core 包，ApplicationContext 是 BeanFactory 的子接口。

除非有充分的理由（比如资源有限，如手机、applet），你才应该考虑使用 BeanFactory。一般情况下，建议使用 ApplicationContext，因为后者提供更多功能，ApplicationContext 是 BeanFactory 的子接口。

最常用的 ApplicationContext 实现类：

• FileSystemXmlApplicationContext：xml 文件的绝对路径（文件系统）。
• ClassPathXmlApplicationContext：xml 文件的相对路径（ClassPath）。
• WebXmlApplicationContext：使用 web 程序中的所有 bean 定义（见后）。

Bean 定义

构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。bean 是一个由 Spring IoC 容器实例化，组装和管理的对象。这些 bean 是使用您提供给容器的配置元数据创建的。例如，以前面章节中已经看到的 XML <bean/> 定义的形式。

Bean 定义包含称为 配置元数据 的信息，容器需要知道以下内容

• Bean 的创建细节
• Bean 的生命周期
• Bean 的依赖关系

这些配置元数据通常都可以使用以下属性表示：

• class：必须属性，指定 bean 对应的类（通常这个类名为全限定类名）。
• name：bean 的唯一标识符，可以使用 id 或 name 属性来指定这个标识。
• scope：指定对应 bean 的范围（应当理解为作用范围，默认为单例模式）。
• constructor-arg：构造函数所需的参数，用于注入依赖项，后续章节讨论。
• properties：bean 对象 setter 属性值，用于注入依赖项，后续章节讨论。
• autowiring mode：意思为自动装配的模式，用于注入依赖项，后续章节讨论。
• lazy-initialization mode：懒加载模式，只在首次使用 bean 时进行实例化。
• initialization method：bean 对象的初始化方法（回调函数），后续章节讨论。
• destruction method：bean 对象的销毁方法（回调函数，同上），后续章节讨论。

配置 bean 元数据的方法

• XML-based configuration file
• Annotation-based configuration
• Java-based configuration（不推荐）

Spring 3 开始，支持 JavaConfig 形式的配置，可以没有 xml 文件，不过就目前来说，spring.xml 形式仍然是主流形式，不过我们最好还是来熟悉一下 JavaConfig 的配置形式，免得以后看到这种配置而一脸懵逼。

XML 配置形式：
spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="helloBean" class="com.mkyong.hello.impl.HelloWorldImpl">
</beans>

JavaConfig 配置形式

package com.mkyong.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.mkyong.hello.HelloWorld;
import com.mkyong.hello.impl.HelloWorldImpl;
@Configuration
public class AppConfig {
    @Bean(name="helloBean")
    public HelloWorld helloWorld() {
        return new HelloWorldImpl();
    }
}

XML 形式的容器初始化：

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

JavaConfig 形式的容器初始化：

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

注意，JavaConfig 形式又称为 Java-Based 形式，都是一个意思，另外，Spring MVC 上如果要使用 Java-Based 配置形式，需要弄什么 WebApplicationInitializer，总之我感觉不如直接配置 web.xml 和 mvc.xml 来的直接。

最常用的是 XML 配置文件与 Java 注解形式，目前先介绍 XML 文件形式。注解形式后面会详细介绍，但在这之前，我们还是需要先了解基本配置方法以及其他一些重要的基础知识。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"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <!-- A simple bean definition -->
   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   <!-- A bean definition with lazy init set on -->
   <bean id = "..." class = "..." lazy-init = "true">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   <!-- A bean definition with initialization method -->
   <bean id = "..." class = "..." init-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   <!-- A bean definition with destruction method -->
   <bean id = "..." class = "..." destroy-method = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
</beans>

Bean 作用域

作用域就是前面提到的 scope 属性，所谓作用域其实就是 bean 对象的生命周期，是的，叫做生命周期通常更好理解。默认支持以下五种生命周期，其中前两种是所有 spring 容器都可用，后三种只在支持 web 的 application context 中可用（比如 spring mvc 中可以使用后三种作用域，前两种是通用的）：

• singleton：单例（默认），单个 IoC 容器中只存在一个 bean 实例。
• prototype：原型，每次获取 bean 对象时，都强制生成新的 bean 实例。
• request：请求，bean 实例只存活于同一个 request 对象，仅用于 web。
• session：会话，bean 实例只存活于同一个 session 对象，仅用于 web。
• global-session：全局会话，对 portlet 有特殊作用，其余同 session。

通常 global-session 不会被用到，所以我们可以说 spring 里面的 bean 作用域有四个，分别是 单例模式、原型模式、请求范围、会话范围。后两个用于 web，比较好理解，单例模式是指同一时间，同一个 IoC 容器中只存在同一个 bean 类的实例，这是默认作用范围，而原型则是每次 getBean() 返回的对象都不相同。

Bean 回调

在某些时候，我们可能需要在构造 bean 时执行一些初始化操作，然后在销毁 bean 时执行一些资源释放操作，spring 允许我们这么做，我们只需使用 init-method、destroy-method 属性告诉 spring，对应的 init 方法名和 destroy 方法名（init、destroy 方法签名不应该接收任何参数，返回任何值）。

需要注意的是，如果在非 web 环境中使用 spring 的 IoC 容器，且注册了 destroy-method 回调，请记得对 IoC 容器对象调用 context.registerShutdownHook() 方法，来向 JVM 注册 shutdown hook 钩子，不然 destroy hook 是不会被执行的。之所以 web 环境中不需要这么做是因为 web 容器会确保 Spring 的 IoC 容器正常 shutdown。

HelloWorld 类：

package com.zfl9;
public class HelloWorld {
    private String message;
    public HelloWorld() {
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    @Override
    public String toString() {
        return String.format("message: %s", this.message);
    }
    public void init() {
        System.out.println("init bean");
    }
    public void destroy() {
        System.out.println("destroy bean");
    }
}

MainApp 类：

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        ((AbstractApplicationContext) context).registerShutdownHook();
        HelloWorld helloworld = (HelloWorld) context.getBean("helloworld");
        System.out.println(helloworld);
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="helloworld" class="com.zfl9.HelloWorld" init-method="init" destroy-method="destroy">
    <property name="message" value="Hello, Spring!"/>
  </bean>
</beans>

运行结果：

init bean
message: Hello, Spring!
destroy bean

如果你有太多的 bean 具有相同名称的初始化或销毁方法，则不需要在每个单独的 bean 上声明 init-method 和 destroy-method。相反，框架提供了使用 <beans> 元素上的 default-init-method 和 default-destroy-method 属性配置此类情况的灵活性，如下所示 ：

<beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
       default-init-method = "init" 
       default-destroy-method = "destroy">
   <bean id = "..." class = "...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
</beans>

Bean 处理器

BeanPostProcessor 是用来扩展默认的 Spring IoC 容器的初始化逻辑，即在 spring 创建 bean 对象前调用某些方法，在 spring 创建 bean 对象之后调用某些方法，我们来看一下这个简单的例子。

HelloWorld 类不变，我们添加一个新的类，为 HelloWorld bean 添加 post 处理器，InitHelloWorld：

package com.zfl9;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class InitHelloWorld implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String name) throws BeansException {
        System.out.println("<pre-init> beanName: " + name);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String name) throws BeansException {
        System.out.println("<post-init> beanName: " + name);
        return bean;
    }
}

然后修改 beans.xml 文件，注册一个新的 bean，class 为 InitHelloWorld，可以有多个 post 处理器：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="helloworld" class="com.zfl9.HelloWorld" init-method="init" destroy-method="destroy">
    <property name="message" value="Hello, Spring!"/>
  </bean>
  <bean class="com.zfl9.InitHelloWorld"/>
</beans>

运行结果如下：

<pre-init> beanName: helloworld
init bean
<post-init> beanName: helloworld
message: Hello, Spring!
destroy bean

注意，这个 BeanPostProcessor 是针对所有 bean 都有效的。

Bean 继承

子 bean 将从父 bean 中继承配置数据，当然子 bean 中可以覆盖父 bean 中定义的值也可以添加新的值，这与 Java 的继承概念很相似，虽然 Bean 的继承与 Java 的继承没有什么关系，但是它们的概念以及作用都是相同的，提取公共的部分。在 XML 文件中，可以在子 bean 中使用 parent 属性指定当前 Bean 的父 Bean（注意 parent 的值时其父 bean 的 ID，不是全限定类名）。

还有一点需要说明的是，父 bean 与子 bean 的 class 之间是没有什么关系的，不存在继承关系，你应该将 bean 之间的继承理解为 bean 的 property 数据的继承，请看下面的例子，HelloWorld 和 HelloChina。

HelloWorld 类：

package com.zfl9;
public class HelloWorld {
    private String message1;
    private String message2;
    public HelloWorld() {
    }
    public String getMessage1() {
        return message1;
    }
    public void setMessage1(String message1) {
        this.message1 = message1;
    }
    public String getMessage2() {
        return message2;
    }
    public void setMessage2(String message2) {
        this.message2 = message2;
    }
    @Override
    public String toString() {
        return String.format("HelloWorld { message1: '%s', message2: '%s' }", this.message1, this.message2);
    }
}

HelloChina 类：

package com.zfl9;
public class HelloChina {
    private String message1;
    private String message2;
    private String message3;
    public HelloChina() {
    }
    public String getMessage1() {
        return message1;
    }
    public void setMessage1(String message1) {
        this.message1 = message1;
    }
    public String getMessage2() {
        return message2;
    }
    public void setMessage2(String message2) {
        this.message2 = message2;
    }
    public String getMessage3() {
        return message3;
    }
    public void setMessage3(String message3) {
        this.message3 = message3;
    }
    @Override
    public String toString() {
        return String.format("HelloChina { message1: '%s', message2: '%s', message3: '%s' }", this.message1, this.message2, this.message3);
    }
}

IocMain 类：

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        System.out.println(helloWorld);
        HelloChina helloChina = (HelloChina) context.getBean("helloChina");
        System.out.println(helloChina);
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="helloWorld" class="com.zfl9.HelloWorld">
    <property name="message1" value="Hello"/>
    <property name="message2" value="World"/>
  </bean>
  <bean id="helloChina" class="com.zfl9.HelloChina" parent="helloWorld">
    <property name="message2" value="江西"/>
    <property name="message3" value="赣州"/>
  </bean>
</beans>

运行结果如下：

HelloWorld { message1: 'Hello', message2: 'World' }
HelloChina { message1: 'Hello', message2: '江西', message3: '赣州' }

bean 模板
bean 模板与 bean 继承很相似，只是父 bean 没有所谓 class 属性，它只是一个单纯的数据载体（模板）：

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <bean id = "beanTeamplate" abstract = "true">
      <property name = "message1" value = "Hello World!"/>
      <property name = "message2" value = "Hello Second World!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
   <bean id = "helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "beanTeamplate">
      <property name = "message1" value = "Hello India!"/>
      <property name = "message3" value = "Namaste India!"/>
   </bean>
</beans>

注意 beanTemplate 的 abstract 属性，true 表示这是模板，没有对应的 class，IoC 容器不会实例化它。

依赖注入

所谓依赖注入就是一个对象获取它所依赖对象的方式是被动的，而不是主动的，因为这个控制权反转了，所以也被称为控制反转。所谓主动获取依赖就是自己 new 出依赖对象，而被动获取则是通过 构造函数、setter 方法 来将依赖对象传递给自己，这个传递依赖对象的过程有个专业名词 - 依赖注入。

您可以混合使用基于 构造函数 和基于 Setter 方法 的依赖注入，但是一个好的经验法则是：对于 必选依赖项，建议使用 构造函数 来注入，对于 可选依赖项，建议使用 setter 方法 来注入。

基于构造函数参数的依赖注入
TextEditor：

package com.zfl9;
public class TextEditor {
    private SpellChecker spellChecker;
    public TextEditor(SpellChecker spellChecker) {
        System.out.println("Inside TextEditor constructor.");
        this.spellChecker = spellChecker;
    }
    public void checkSpelling() {
        this.spellChecker.checkSpelling();
    }
}

SpellChecker：

package com.zfl9;
public class SpellChecker {
    public SpellChecker() {
        System.out.println("Inside SpellChecker Constructor.");
    }
    public void checkSpelling() {
        System.out.println("Inside SpellChecker checkSpelling.");
    }
}

IocMain：

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        TextEditor textEditor = (TextEditor) context.getBean("textEditor");
        textEditor.checkSpelling();
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="spellChecker" class="com.zfl9.SpellChecker"/>
  <bean id="textEditor" class="com.zfl9.TextEditor">
    <constructor-arg ref="spellChecker"/>
  </bean>
</beans>

运行结果：

Inside SpellChecker Constructor.
Inside TextEditor constructor.
Inside SpellChecker checkSpelling.

我们知道 Java 中有两大数据类型：基本类型、引用类型。基本类型共有八种，分别为 short、int、long、float、double、boolean、byte、char，这八种基本类型都可以使用字面值表示，所以在 beans.xml 文件中，使用 value 属性来存储它们的值（前面已经演示很多次了），而对于引用类型，比如上面的 SpellChecker 参数，就是一个引用类型，我们不能通过 value 字面值来表示它，所以我们需要先使用 bean 元素在 IoC 容器中注册 spellChecker 对象，然后在 textEditor 对象的构造函数参数中使用 ref 来引用对应的参数的 bean ID。当然，String 对象是可以使用 value 字面量表示的。

问题来了，如果构造器有多个参数需要注入，那么该怎么做呢？有三种方式：

• 按照参数顺序，提供 <constructor-arg>。
• 根据参数类型，提供 <constructor-arg>。
• 根据参数位置，提供 <constructor-arg>。

方法一，按顺序

package x.y;
public class Foo {
   public Foo(Bar bar, Baz baz) {
      // ...
   }
}

<beans>
   <bean id = "foo" class = "x.y.Foo">
      <constructor-arg ref = "bar"/>
      <constructor-arg ref = "baz"/>
   </bean>
   <bean id = "bar" class = "x.y.Bar"/>
   <bean id = "baz" class = "x.y.Baz"/>
</beans>

方法二，按类型

package x.y;
public class Foo {
   public Foo(int year, String name) {
      // ...
   }
}

<beans>
   <bean id = "exampleBean" class = "examples.ExampleBean">
      <constructor-arg type = "int" value = "2001"/>
      <constructor-arg type = "java.lang.String" value = "Zara"/>
   </bean>
</beans>

方法三，按索引（推荐）
注意索引值是从 0 开始的，大家应该很熟悉吧。

<beans>
   <bean id = "exampleBean" class = "examples.ExampleBean">
      <constructor-arg index = "0" value = "2001"/>
      <constructor-arg index = "1" value = "Zara"/>
   </bean>
</beans>

第二种方法不是很好，如果参数类型都相同就很尴尬了，第一种可读性稍微差点，所以第三种方式最好。例子：

Container.java

package com.zfl9;
import java.io.IOException;
import java.sql.SQLException;
public class Container {
    private IOException ioException;
    private SQLException sqlException;
    private RuntimeException runtimeException;
    public Container(IOException ioException, SQLException sqlException, RuntimeException runtimeException) {
        this.ioException = ioException;
        this.sqlException = sqlException;
        this.runtimeException = runtimeException;
    }
    public IOException getIoException() {
        return ioException;
    }
    public void setIoException(IOException ioException) {
        this.ioException = ioException;
    }
    public SQLException getSqlException() {
        return sqlException;
    }
    public void setSqlException(SQLException sqlException) {
        this.sqlException = sqlException;
    }
    public RuntimeException getRuntimeException() {
        return runtimeException;
    }
    public void setRuntimeException(RuntimeException runtimeException) {
        this.runtimeException = runtimeException;
    }
    @Override
    public String toString() {
        return String.format("Container {\n\tIOException: %s\n\tSQLException: %s\n\tRuntimeException: %s\n}", this.ioException, this.sqlException, this.runtimeException);
    }
}

IocMain.java

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        TextEditor textEditor = (TextEditor) context.getBean("textEditor");
        textEditor.checkSpelling();
        Container container = (Container) context.getBean("container");
        System.out.println(container);
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="spellChecker" class="com.zfl9.SpellChecker"/>
  <bean id="textEditor" class="com.zfl9.TextEditor">
    <constructor-arg ref="spellChecker"/>
  </bean>
  <bean id="ioException" class="java.io.IOException"/>
  <bean id="sqlException" class="java.sql.SQLException"/>
  <bean id="runtimeException" class="java.lang.RuntimeException"/>
  <bean id="container" class="com.zfl9.Container">
    <constructor-arg index="0" ref="ioException"/>
    <constructor-arg index="1" ref="sqlException"/>
    <constructor-arg index="2" ref="runtimeException"/>
  </bean>
</beans>

运行结果：

Inside SpellChecker Constructor.
Inside TextEditor constructor.
Inside SpellChecker checkSpelling.
Container {
    IOException: java.io.IOException
    SQLException: java.sql.SQLException
    RuntimeException: java.lang.RuntimeException
}

基于 Setter 方法的依赖注入
基于 setter 的方式其实我们前面已经用了很多次了，就是 property 元素的运用而已，再次强调一点，constructor-arg 是用来指定构造器参数的（构造函数 DI），而 property 是用来指定对象属性的（setter 方法 DI），我们继续以上面的 TextEditor 为例，演示如何使用 settter 方式进行 DI。

TextEditor.java

package com.zfl9;
public class TextEditor {
    private SpellChecker spellChecker;
    public TextEditor() {
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public void setSpellChecker(SpellChecker spellChecker) {
        this.spellChecker = spellChecker;
    }
    public void checkSpelling() {
        this.spellChecker.checkSpelling();
    }
}

SpellChecker.java

package com.zfl9;
public class SpellChecker {
    public SpellChecker() {
        System.out.println("Inside SpellChecker Constructor.");
    }
    public void checkSpelling() {
        System.out.println("Inside SpellChecker checkSpelling.");
    }
}

IocMain.java

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        TextEditor textEditor = (TextEditor) context.getBean("textEditor");
        textEditor.checkSpelling();
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="spellChecker" class="com.zfl9.SpellChecker"/>
  <bean id="textEditor" class="com.zfl9.TextEditor">
    <property name="spellChecker" ref="spellChecker"/>
  </bean>
</beans>

运行结果：

Inside SpellChecker Constructor.
Inside SpellChecker checkSpelling.

使用 p-namespace 设置 property 属性
传统方式：

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <bean id = "john-classic" class = "com.example.Person">
      <property name = "name" value = "John Doe"/>
      <property name = "spouse" ref = "jane"/>
   </bean>
   <bean id = "jane" class = "com.example.Person">
      <property name = "name" value = "John Doe"/>
   </bean>
</beans>

改进方式：

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
       xmlns:p = "http://www.springframework.org/schema/p"
       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation = "http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <bean id = "john-classic"
         class = "com.example.Person"
         p:name = "John Doe"
         p:spouse-ref = "jane"/>
   <bean id =" jane"
         class = "com.example.Person"
         p:name = "John Doe"/>
</beans>

在这里，您应该注意使用 p-namespace 指定原始值和对象引用的区别。该 -ref 部分表示这是另一个 bean 的引用，而非 property 名称，因为 java 标识符规范规定 - 不是一个有效字符，所以可以这么做。

内部 Bean

内部 Bean 和 Java 内部类很相似，我们之所以要使用 Java 内部类，是为了体现外部类和内部类的一个层级关系，比如 Map 和 Map.Entry，它们是一个归属关系，这也是为什么使用内部类比使用外部类更有说明力的理由。在 spring ioc 容器中，我们也可以定义内部 bean，比如之前的构造函数注入、setter 方法注入中，我们会使用 ref 来引用 ioc 容器中的其它 bean 实例，但这些 bean 的作用仅仅是作为参数、属性值，所以我们可以将它们定义在需要它们的 bean 的内部，这样更加整洁，也能避免对全局命名空间进行污染。

还是以前面的 setter 方法注入为例子，我们可以这样写 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"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <!-- Definition for textEditor bean using inner bean -->
   <bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
      <property name = "spellChecker">
         <bean class = "com.tutorialspoint.SpellChecker"/>
      </property>
   </bean>
</beans>

注入集合

前面我们都是注入的标量值，这一节我们来看看如何注入集合类型的值。spring ioc 容器支持以下 4 种集合类型的注入：

• <list>：java.util.List，列表，允许重复。
• <set>：java.util.Set，集合，不保留任何重复元素。
• <map>：java.util.Map，键值对，key、value 可以是任意类型。
• <props>：java.util.Properties，键值对，key、value 为字符串。

例子，JavaCollection.java：

package com.zfl9;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class JavaCollection {
    private List list;
    private Set set;
    private Map map;
    private Properties props;
    public JavaCollection() {
    }
    public List getList() {
        System.out.println(list);
        return list;
    }
    public void setList(List list) {
        this.list = list;
    }
    public Set getSet() {
        System.out.println(set);
        return set;
    }
    public void setSet(Set set) {
        this.set = set;
    }
    public Map getMap() {
        System.out.println(map);
        return map;
    }
    public void setMap(Map map) {
        this.map = map;
    }
    public Properties getProps() {
        System.out.println(props);
        return props;
    }
    public void setProps(Properties props) {
        this.props = props;
    }
}

IocMain.java：

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        JavaCollection javaCollection = (JavaCollection) context.getBean("javaCollection");
        javaCollection.getList();
        javaCollection.getSet();
        javaCollection.getMap();
        javaCollection.getProps();
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="javaCollection" class="com.zfl9.JavaCollection">
    <property name="list">
      <list>
        <value>www.zfl9.com</value>
        <value>www.zfl9.com</value>
        <value>www.baidu.com</value>
        <value>www.google.com</value>
      </list>
    </property>
    <property name="set">
      <set>
        <value>www.zfl9.com</value>
        <value>www.zfl9.com</value>
        <value>www.baidu.com</value>
        <value>www.google.com</value>
      </set>
    </property>
    <property name="map">
      <map>
        <entry key="1" value="zfl9"/>
        <entry key="2" value="baidu"/>
        <entry key="3" value="google"/>
      </map>
    </property>
    <property name="props">
      <props>
        <prop key="1">zfl9</prop>
        <prop key="2">baidu</prop>
        <prop key="3">google</prop>
      </props>
    </property>
  </bean>
</beans>

运行结果：

[www.zfl9.com, www.zfl9.com, www.baidu.com, www.google.com]
[www.zfl9.com, www.baidu.com, www.google.com]
{1=zfl9, 2=baidu, 3=google}
{3=google, 2=baidu, 1=zfl9}

引用其它 bean
除了上面这种字面量提供的方式的外，我们也可以引用其他 bean 来提供数据，如下：

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <!-- Bean Definition to handle references and values -->
   <bean id = "..." class = "...">
      <!-- Passing bean reference  for java.util.List -->
      <property name = "addressList">
         <list>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </list>
      </property>
      <!-- Passing bean reference  for java.util.Set -->
      <property name = "addressSet">
         <set>
            <ref bean = "address1"/>
            <ref bean = "address2"/>
            <value>Pakistan</value>
         </set>
      </property>
      <!-- Passing bean reference  for java.util.Map -->
      <property name = "addressMap">
         <map>
            <entry key = "one" value = "INDIA"/>
            <entry key = "two" value-ref = "address1"/>
            <entry key = "three" value-ref = "address2"/>
         </map>
      </property>
   </bean>
</beans>

注入空字符串

<bean id = "..." class = "exampleBean">
   <property name="email" value=""/>
</bean>

注入 null 值

<bean id = "..." class = "exampleBean">
   <property name="email"><null/></property>
</bean>

自动装配

所谓自动装配就是 Spring 自动查找 property 或 constructor-arg 的 reference，我们之前的所有配置都是手动装配的，因为所有的 property 或 constructor-arg 都是手动配置的，现在来学习“自动装配”。

在 IoC 容器中查找“符合条件”的 bean，然后装配到 bean 上的行为就叫做“自动装配”。

no
这是默认值，表示不是自动装配，也就是说这是“手动装配”。

byName
所谓 byName 自动装配模式，就是 Spring 自动在 IoC 容器中查找与 property name 相同的 bean，然后装配到当前 bean，一句话就是：查找与属性名称相同的 bean，然后进行装配。

例子：
TextEditor.java

package com.zfl9;
public class TextEditor {
    private SpellChecker spellChecker;
    public TextEditor() {
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public void setSpellChecker(SpellChecker spellChecker) {
        this.spellChecker = spellChecker;
    }
    public void checkSpelling() {
        spellChecker.checkSpelling();
    }
}

SpellChecker.java

package com.zfl9;
public class SpellChecker {
    public SpellChecker() {
        System.out.println("SpellChecker.constructor()");
    }
    public void checkSpelling() {
        System.out.println("SpellChecker.checkSpelling()");
    }
}

IocMain.java

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        TextEditor textEditor = (TextEditor) context.getBean("textEditor");
        textEditor.checkSpelling();
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="spellChecker" class="com.zfl9.SpellChecker"/>
  <bean id="textEditor" class="com.zfl9.TextEditor" autowire="byName"/>
</beans>

注意原先我们是怎么写的：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="spellChecker" class="com.zfl9.SpellChecker"/>
  <bean id="textEditor" class="com.zfl9.TextEditor">
    <property name="spellChecker" ref="spellChecker"/>
  </bean>
</beans>

注意，使用自动装配时我们仍然可以手动指定一些属性，这没有任何影响，比如：

全部都手动装配：

<beans>
   <bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
      <property name = "spellChecker" ref = "spellChecker" />
      <property name = "name" value = "Generic Text Editor" />
   </bean>
   <bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"></bean>
</beans>

自动装配与手动装配混合：

<beans>
   <bean id = "textEditor" class = "com.tutorialspoint.TextEditor" autowire = "byName">
      <property name = "name" value = "Generic Text Editor" />
   </bean>
   <bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"></bean>
</beans>

byType
和 byName 差不多，byType 是查找与属性类型相匹配的 bean，然后自动装配上去。

TextEditor.java

package com.zfl9;
public class TextEditor {
    private String name;
    private SpellChecker spellChecker;
    public TextEditor() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public void setSpellChecker(SpellChecker spellChecker) {
        this.spellChecker = spellChecker;
    }
    public void checkSpelling() {
        spellChecker.checkSpelling();
    }
}

SpellChecker.java

package com.zfl9;
public class SpellChecker {
    public SpellChecker() {
        System.out.println("SpellChecker.constructor()");
    }
    public void checkSpelling() {
        System.out.println("SpellChecker.checkSpelling()");
    }
}

IocMain.java

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        TextEditor textEditor = (TextEditor) context.getBean("textEditor");
        textEditor.checkSpelling();
        SpellChecker spellChecker = (SpellChecker) context.getBean("com.zfl9.SpellChecker");
        spellChecker.checkSpelling();
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean class="com.zfl9.SpellChecker"/>
  <bean id="textEditor" class="com.zfl9.TextEditor" autowire="byType">
    <property name="name" value="Otokaze"/>
  </bean>
</beans>

运行结果：

SpellChecker.constructor()
SpellChecker.checkSpelling()
SpellChecker.checkSpelling()

注意，因为 bean 定义中，只有 class 属性时必选的，其他属性都是可以省略的，上面我们省略了 com.zfl9.SpellChecker 类的 bean ID，而默认的 ID 就是 class 的全限定类名，所以我们可以在 IocMain.java 中使用这个 ID 找到这个 Bean。其他的什么与 byName 一样，不再解释。

更新：如果 bean 定义没有提供 id 或 name 属性，那么我们仍然可以通过 bean 的全限定类名来访问它（但不要认为这个 bean 的标识符就是它的全限定类名。）

constructor
这种类型的自动装配其实与 byType 非常相似，都是按照类型进行匹配，但是 constructor 装配模式适用于构造器参数的自动装配，而 byType 则适用于对象属性的自动装配（setter 方法），我们来看例子：

TextEditor.java

package com.zfl9;
public class TextEditor {
    private String name;
    private SpellChecker spellChecker;
    public TextEditor(String name, SpellChecker spellChecker) {
        this.name = name;
        this.spellChecker = spellChecker;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public void setSpellChecker(SpellChecker spellChecker) {
        this.spellChecker = spellChecker;
    }
    public void checkSpelling() {
        spellChecker.checkSpelling();
    }
}

IocMain.java

package com.zfl9;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        TextEditor textEditor = (TextEditor) context.getBean("textEditor");
        textEditor.checkSpelling();
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean class="com.zfl9.SpellChecker"/>
  <bean id="textEditor" class="com.zfl9.TextEditor" autowire="constructor">
    <constructor-arg name="name" value="Otokaze"/>
  </bean>
</beans>

运行结果：

SpellChecker.constructor()
SpellChecker.checkSpelling()

autodetect
自动选择模式，即首先尝试使用 constructor 模式，如果不行，就使用 byType 模式。

自动装配的缺点
虽然使用自动装配可以减少 XML 文件的配置，但是除非大家都使用自动装配，否则这种只写一部分 property、constructor-arg 的方式可能会让人感到疑惑，导致 XML 文件的可读性降低，甚至带来混淆。

1. 自动装配的实例属性/构造器参数仍然可以通过 <property>、<constructor-arg> 元素覆盖。
2. 对于某些特殊数据类型，无法使用自动装配，比如基本数据类型、String 字符串、Class 类。
3. 令人感到疑惑，可读性不好，所以除非有充分的理由，否则不是很建议使用自动装配。

注解装配

从 Spring 2.5 版本开始，支持使用 Java 注解对依赖注入进行配置（之前是全部通过 XML 文件进行配置，现在我们可以使用 Java 注解类进行辅助配置，甚至完全使用 Java 注解进行 DI 配置也是可行的）。Spring 默认没有开启注解装配的支持，所以我们需要在 beans.xml 文件中加入 <context:annotation-config/>，具体的：

<?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: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.xsd">
  <context:annotation-config/>
</beans>

稍微解释一下 context:annotation-config 的作用，配置该元素后，Spring 会自动扫描 application context 中的 bean 上面配置的 Java 注解，并且激活它们。也就是说，添加这行后，Spring 会自动应用 IoC 容器中的 bean 的对应类上面的 Java 注解，这下应该理解了吧。

也就是说，只有位于 application context 容器中的 bean 上面的注解才会被 Spring 扫描并激活。

那么 context:annotaion-config 设置后，Spring 会扫描 bean 上面的哪些注解呢：

• @Required：用在 setter 方法上，表示对应的 property 必须被提供，否则运行会发生异常。
• @Autowired：用在成员方法、构造方法、方法参数、实例属性上，实现 byType 按类型自动装配。
• @Qualifier：与 @Autowired 一起使用，指定自动装配的条件，以消除 bean 名字相同的歧义。
• @Resource：JSR-250 注解，可以理解为 byName 模式的自动装配，@Autowired 属于 byType。
• @PostConstruct：JSR-250 注解，可以用来替代 init-method 属性指定的回调函数（后面详解）。
• @PreDestroy：JSR-250 注解，可以用来替代 destroy-method 属性指定的回调函数（后面详解）。

@Required
该 @Required 注解适用于 bean 属性的 setter 方法，并表示受影响的 bean 属性必须在 XML 配置文件在配置时进行填充。否则，容器抛出 BeanInitializationException异常。以下示例显示@Required注释的使用。

Student.java
我们给 name 和 age 属性对应的 setter 方法标注了 @Required，表示他们是必选属性。

package com.zfl9;
import org.springframework.beans.factory.annotation.Required;
public class Student {
    private String name;
    private Integer age;
    public Student() {
    }
    public String getName() {
        return name;
    }
    @Required
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    @Required
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return String.format("Student: [ name = '%s', age = %d ]", name, age);
    }
}