上一篇我们介绍了 Spring Framework IoC的Setter依赖注入，本篇我们一起来看一下Spring Framework IoC构造函数依赖注入。这里我总结了以下几种方式：

复制
 * 手动模式
* XML资源配置元信息
*  Java 注解配置元信息
* API配置元信息
* 自动模式
*  Constructor 

接下来我们就通过实际案例一起来实战以下。代码如下：

复制
 <?xml version=".0" encoding="UTF-8"?>
<beans xmlns=" Spring framework.org/schema/beans"
       xmlns:xsi="#;
       xsi:schemaLocation="
        #;>
 
    <import resource="classpath:/"/>
 
    <bean class="org.eleven.thinking.in.spring.ioc.dependency.injection.UserHolder">
        <constructor-arg name="user" ref="superUser" />
    </bean>
 
</beans>
 
 
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */package org.eleven.thinking.in.spring.ioc.dependency.injection;
 
import org.springframework. Bean s.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
 
/**
 * 基于 XML 资源的依赖 Constructor 注入示例
 *
 * @author <a href="mailto:eleven.hm@vip..com">eleven</a>
 * @since
 */public class XmlDependencyConstructorInjectionDemo {
 
    public  static   void  main(String[] args) {
 
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
 
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
 
        String xmlResourcePath = "classpath:/META-INF/dependency-constructor-injection.xml";
        // 加载 XML 资源，解析并且生成 BeanDefinition
        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);
        // 依赖查找并且创建 Bean
        UserHolder userHolder = beanFactory.getBean(UserHolder.class);
        System.out.println(userHolder);
 
    }
} 

以上就是通过XML资源配置方式实现构造函数注入，这里我们可以看出，其实只需要将配置中的属性依赖改成 构造函数 依赖的方式就行了。接下来我们看一下注解配置资源的构造函数注入方式：

复制
 /*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */package org.eleven.thinking.in.spring.ioc.dependency.injection;
 
import org.eleven.thinking.in.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context. annotation .AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
 
/**
 * 基于 Java 注解的依赖 Constructor 注入示例
 *
 * @author <a href="mailto:eleven.hm@vip..com">eleven</a>
 * @since
 */public class AnnotationDependencyConstructorInjectionDemo {
 
    public static void main(String[] args) {
 
        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 注册 Configuration Class（配置类）
        applicationContext.register(AnnotationDependencyConstructorInjectionDemo.class);
 
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);
 
        String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";
        // 加载 XML 资源，解析并且生成 BeanDefinition
        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);
 
        // 启动 Spring 应用上下文
        applicationContext.refresh();
 
        // 依赖查找并且创建 Bean
        UserHolder userHolder = applicationContext.getBean(UserHolder.class);
        System.out.println(userHolder);
 
        // 显示地关闭 Spring 应用上下文
        applicationContext.close();
    }
 
    @Bean
    public UserHolder userHolder(User user) {
        return new UserHolder(user);
    }
} 

以上就是通过注解配置资源的方式来实现构造函数注入。接下来我们一起看一下通过 Java API 资源配置的方式来实现构造函数注入依赖，代码如下：

复制
 <?xml version=".0" encoding="UTF-8"?>
<beans xmlns="#;
       xmlns:xsi="#;
       xsi:schemaLocation="
        #;>
 
    <import resource="classpath:/META-INF/dependency-lookup-context.xml"/>
 
    <bean class="org.eleven.thinking.in.spring.ioc.dependency.injection.UserHolder"
          autowire="constructor">
        <!--        <property name="user" ref="superUser" /> 替换成 autowiring 模式 -->
    </bean>
 
</beans>
 
 
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */package org.eleven.thinking.in.spring.ioc.dependency.injection;
 
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
/**
 * 基于 API 实现依赖 Constructor 注入示例
 *
 * @author <a href="mailto:eleven.hm@vip..com">eleven</a>
 * @since
 */public class ApiDependencyConstructorInjectionDemo {
 
    public static void main(String[] args) {
 
        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
 
        // 生成 UserHolder 的 BeanDefinition
        BeanDefinition userHolderBeanDefinition = createUserHolderBeanDefinition();
        // 注册 UserHolder 的 BeanDefinition
        applicationContext.registerBeanDefinition("userHolder", userHolderBeanDefinition);
 
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);
 
        String xmlResourcePath = "classpath:/META-INF/dependency-lookup-context.xml";
        // 加载 XML 资源，解析并且生成 BeanDefinition
        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);
 
        // 启动 Spring 应用上下文
        applicationContext.refresh();
 
        // 依赖查找并且创建 Bean
        UserHolder userHolder = applicationContext.getBean(UserHolder.class);
        System.out.println(userHolder);
 
        // 显示地关闭 Spring 应用上下文
        applicationContext.close();
    }
 
    /**
     * 为 {@link UserHolder} 生成 {@link BeanDefinition}
     *
     * @return
     */     private  static BeanDefinition createUserHolderBeanDefinition() {
        BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(UserHolder.class);
        definitionBuilder.addConstructorArgReference("superUser");
        return definitionBuilder.getBeanDefinition();
    }
 
    //    @Bean
    //    public UserHolder userHolder(User user) { // superUser -> primary = true
    //        UserHolder userHolder = new UserHolder();
    //        userHolder.setUser(user);
    //        return userHolder;
    //    }
} 

以上是通过手动模式进行配置元信息的方式，接下来我们一起看一下通过自动模式配置元信息的方式，代码如下：

复制
 /*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */package org.eleven.thinking.in.spring.ioc.dependency.injection;
 
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
 
/**
 * "constructor" Autowiring 依赖构造器注入示例
 *
 * @author <a href="mailto:eleven.hm@vip..com">eleven</a>
 * @since
 */public class AutoWiringConstructorDependencyConstructorInjectionDemo {
 
    public static void main(String[] args) {
 
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
 
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
 
        String xmlResourcePath = "classpath:/META-INF/autowiring-dependency-constructor-injection.xml";
        // 加载 XML 资源，解析并且生成 BeanDefinition
        beanDefinitionReader.loadBeanDefinitions(xmlResourcePath);
        // 依赖查找并且创建 Bean
        UserHolder userHolder = beanFactory.getBean(UserHolder.class);
        System.out.println(userHolder);
    }
} 

以上就是通过构造函数进行依赖注入的相关实践。