Spring Java代码配置 Java Bean

Spring 通过 Java 代码配置 Java Bean

Java Bean 配置的第二节 也是现在常用的JavaBean配置方式

代码配置 Java Bean 的整体流程

第 1 步
准备好一个配置类（XxxConfig）。其中写一个或多个方法，每个方法负责返回你的项目中的（逻辑上的）单例对象。

至于你的项目中是有多少个单例对象，那就需要你自己去分析、去设计。

例如：

public class XxxConfig {
      
  @Bean
  public DataSource dataSource() throws Exception {
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/scott?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false");
    dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");

    return dataSource;
  }
}

第 2 步
创建 AnnotationConfigApplicationContext 对象（它就是我们口头所说的 Spring IoC 容器），并将上述的配置类作为参数传递给它。

例如：

AnnotationConfigApplicationContext context = 
  new AnnotationConfigApplicationContext(YyyConfig.class);

在这个操作背后发生了这样的一件事情：Spring IoC 容器会去调用，你上述的配置类中的标注了 @Bean 的方法。它只调用一次，并将这些方法的返回值（各个对象的引用）保存起来。

毫无疑问，这个对象必定就是单例的。

第 3 步
根据我们自己的需要，你可以向 Spring IoC 容器要（通过 “getBean” 方法）上述的配置类中的这么些个单例对象。

例如：

DataSource ds = context.getBean(DataSource.class);
Connection connection = ds.getConnection();
...

在获得这些单例对象之后，你要干什么，就是你自己的事情了。

创建对象的 3 种方式

再次强调
以何种方式创建对象（包括如何赋值，赋什么值）这是程序员自己考虑的事情，Spring IoC 并不关心。它只关心、关注你所提供的方法的返回值（对象）。

创建 Bean ，常见的方式常见 3 种：

#	方式
1	类自身的构造方法
2	工厂类提供的工厂方法
3	工厂对象提供的工厂方法

在 Spring 的代码配置中，你自己决定使用何种方式创建对象并返回：

通过类自身的构造方法

例如：

@Bean
public DataSource dataSource() throws Exception {
  DruidDataSource dataSource = new DruidDataSource();
  dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/scott?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false");
  dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
  dataSource.setUsername("root");
  dataSource.setPassword("123456");

  return dataSource;
}

工厂类提供的工厂方法

例如：

@Bean
public DataSource dataSource() throws Exception {
  Properties properties = new Properties();
  properties.setProperty("driver", "com.mysql.cj.jdbc.Driver");
  properties.setProperty("url", "jdbc:mysql://127.0.0.1:3306/scott?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false");
  properties.setProperty("username", "root");
  properties.setProperty("password", "123456");

  DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
  
  return dataSource;
}

工厂对象提供的工厂方法

略。

Java Bean 的属性的赋值

在 Java 代码配置中，和 "如何创建对象是程序员的「家务事」，Spring 并不关心"一样，“以何种方式（有参构造 or Setter）为对象的属性赋值，以及赋何值也是程序员的「家务事」”，Spring 也不关心。

上述 @Bean 方法所返回的 Java Bean，对 Spring 而言，其属性有值，就有值，没有值，就没有值；是这个值，就是这个值，是那个值就是那个值。

在 XML 方式的配置中，为 Java Bean 赋初值的配置要啰嗦的多得多。

引用类型的属性的赋值

大多数情况下，在 Java 代码的配置中，为对象的属性赋值都比较直接。但是在 Spring 的容器中，Java Bean 可能会存在引用。

即，一个 Spring 容器中的 Java Bean 的某个属性的值是容器中的另一个 Java Bean 的引用。

在 Java 代码配置中，有多（3）种方式来配置 Java Bean 的引用关系，这里推荐使『通过参数表示引用关系』：

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>${hikaricp.version}</version> <!-- 3.2.0 -->
</dependency>

@Bean
public HikariConfig hikariConfig() {
    HikariConfig config = new HikariConfig();
    config.setDriverClassName("com.mysql.cj.jdbc.Driver");
    config.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/scott?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false");
    config.setUsername("root");
    config.setPassword("123456");

    return config;
}

@Bean
public DataSource dataSource(HikariConfig config) {
    DataSource dataSource = new HikariDataSource(config);
    return dataSource;
}

循环引用

如果 Spring 容器中的两个对象，相互引用，那么会遇到循环引用问题。

!? 如何制造出 “循环引用” 场景？

• 第 1 步：类定义：

public class Husband {
  private Wife wife;
  ... 
}

public class Wife {
  private Husband husband;
  ...
}

• 第 2 步：进行"常规"配置：

@Bean
public Husband husband(Wife wife) { ... }

@Bean
public Wife wife(Husband husband) { ... }

上述 2 步操作就制造出了循环引用。

!? 如何解决 IoC 容器中的循环引用问题？

解决这个问题的办法是对两个 Bean 中的其中一个使用 “@Lazy” 注解：

@Bean
public Husband husband(@Lazy Wife wife) { ... }

@Bean
public Wife wife(Husband husband) { ... }

通过 “@Lazy” 注解，Spring 生成并返回了一个 Wife 的代理对象，因此给 Husband 注入的 Wife 并非真实对象，而是其代理，从而顺利完成了 Husband 实例的构造（而不是报错）；而 Wife 依赖的 Husband 是直注入完整的 Husband 对象本身。因此，这里通过 “@Lazy” 巧妙地避开了循环依赖的发生。