在上一篇文章Dagger2最简单的入门我们写了一个最简单的demo来介绍Dagger2，我们通过@Inject注解构无参造器来注入对象

那么如果构造器有参数，且这个参数也需要注入，又该怎么写呢？

本篇基于上一篇文章Dagger2最简单的入门，代码片段也是以上一篇文章的demo修改的，所以看本篇之前先看上一篇

 

我们先增加一个Teacher类，其中的无参构造方法用@Inject标识

public class Teacher {

    public String name;

    @Inject
    public Teacher() {
        this.name = "苍老湿";
    }

    public Teacher(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return String.format("我的名字叫%s啦", name);
    }
}


然后修改Student类原来的无参构造方法，增加一个Teacher参数，在toString()中增加显示老师的信息

public class Student {

    public String name;
    public Teacher teacher;

    @Inject
    public Student(Teacher teacher) {
        this.name = "野猿新一";
        this.teacher = teacher;
    }

    public Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return String.format("我的名字叫%s啦，我们老师的名字叫%s", name, teacher.name);
    }
}


ok，大工告成，就上面两步，直接运行看看

可以看到，注入Student对象的同时，也成功注入了Teacher对象



我们还是看下Dagger生成代码的注入流程

在MainActivity中调用如下代码

DaggerMainActivityComponent.create().inject(this);

 DaggerMainActivityComponent中innect()方法再调用injectMainActivity()方法

injectMainActivity()方法内部调用了MainActivity_MembersInjector.injectStudent()，传入了activity对象和通过getStudent()方法获取的Student对象

我们看到getStudent()方法中直接new了一个Teacher对象，然后作为参数再new一个Student

@Override
public void inject(MainActivity activity) {
  injectMainActivity(activity);
}

@CanIgnoreReturnValue
private MainActivity injectMainActivity(MainActivity instance) {
  MainActivity_MembersInjector.injectStudent(instance, getStudent());
  return instance;
}

private Student getStudent() {
  return new Student(new Teacher());
}

最后看下MainActivity_MembersInjector的injectStudent()方法，直接将传入student赋值给activity的student成员变量，至此就成功把Student注入到MainActivity中

public static void injectStudent(MainActivity instance, Student student) {
  instance.student = student;
}

 

 

 

 

在Spring MVC中我们会发现一个特别便利的一个小功能,那就是在Controller层映射的方法上

Spring会自动帮我们注入参数，帮我们初始化对象。

比如常用的：

  @RequestParam  :取querystring 当中的参数

  @PathVariable  ：取 在@RequestMapping 中定义的占位符中的参数（/test/{id}）

  @RequestBody  : 取request 这个消息体 一般用（String，byte[] 来接）

等等，更多的就不一一列举了，可以参看 这个包下的注解

（org.springframework.web.bind.annotation）

那么还有一些不需要注解的：如
HttpServletRequest
HttpServletResponse
MultipartFile
MultipartRequest

  Form（此Form 为 任意JavaBean 对象，Spring 会将相关请求参数自动注入）  等等。如此智能的体验，实在是太方便了。那么它们又是怎么工作的呢？ 

在比如一个业务场景，要是我想通过这种方式来自动注入登录用户，那么Spring 的参数注入支不支持自定义注入呢？带着这些好奇心我们来看它的大致工作流程。

其大致流程是 DispaterServlet 接收请求，并开始确定本次请求的 handler。Handler 中确定一个 ServletInvocableHandlerMethod，并初始化一些上下文参数。

 ServletInvocableHandlerMethod 开始执行调用，在调用前确定和实例化该方法需要的参数。确定和实例化调用前需要的参数，使用到了一个List<HandlerMethodArgumentResolver>.OK. 那么Spring 就是通过 HandlerMethodArgumentResolver 来识别和处理它能识别的参数了。




那我们来看看这个接口

public interface HandlerMethodArgumentResolver {   
      boolean supportsParameter(MethodParameter parameter);
       Object resolveArgument(MethodParameter parameter,  ModelAndViewContainer mavContainer,
                   NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;
}


为了节约篇幅，我将注释给删掉了。这个接口由两个类构成，一个方法 supportsParameter用来确定方法上的参数，当前这个Resolver 可不可以处理它，如果支持那么就去处理。

另一个方法 resolveArgument 就很明显了 就是在 supportsParameter 为true 的时候，执行相关处理业务。

看到这里我们可以看出Spring MVC 中方法参数的自动注入是由实现了 HandlerMethodArgumentResolver 的类来完成的，那么文章开始提到的内嵌功能 又是怎么来的呢？聪明的朋友 不难想到，Spring 中肯定初始化了一些默认的resolver。对的，就是这样。我们可在

RequestMappingHandlerAdapter 中找到一个私有方法 getDefaultArgumentResolvers();里面展示了Spring内嵌的Resolver。

 先把这段代码贴一下，大家就知道哪些功能是内嵌的了
private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() { 
  
       List<HandlerMethodArgumentResolver> resolvers = new  ArrayList<HandlerMethodArgumentResolver>();
       // Annotation-based argument resolution   
       resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
       resolvers.add(new RequestParamMapMethodArgumentResolver());
       resolvers.add(new PathVariableMethodArgumentResolver());
       resolvers.add(new PathVariableMapMethodArgumentResolver());
       resolvers.add(new MatrixVariableMethodArgumentResolver());
       resolvers.add(new MatrixVariableMapMethodArgumentResolver());
       resolvers.add(new ServletModelAttributeMethodProcessor(false));
       resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters()));
       resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));
       resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
       resolvers.add(new RequestHeaderMapMethodArgumentResolver());
       resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
       resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
       // Type-based argument resolution   
       resolvers.add(new ServletRequestMethodArgumentResolver());
       resolvers.add(new ServletResponseMethodArgumentResolver());
       resolvers.add(new HttpEntityMethodProcessor(getMessageConverters()));
       resolvers.add(new RedirectAttributesMethodArgumentResolver());
       resolvers.add(new ModelMethodProcessor());
       resolvers.add(new MapMethodProcessor());
       resolvers.add(new ErrorsMethodArgumentResolver());
       resolvers.add(new SessionStatusMethodArgumentResolver());
       resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
       // Custom arguments   
       if (getCustomArgumentResolvers() != null) {
          resolvers.addAll(getCustomArgumentResolvers());
       }
       // Catch-all
       resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
       resolvers.add(new ServletModelAttributeMethodProcessor(true));   return resolvers;
}


OK，那么怎么实现刚刚提到的自动注入登录用户这个功能呢？

首先我们来思考要实现这个功能需要哪几步，答案是两步，

1.我们需要有一个 处理这个业务的 resolver

2. 把这个resolver 给Spring 容器

好我们先来完成第一步，创建一个类 继承 HandlerMethodArgumentResolver ,如：
public class LoginUserArugmentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        /**
         * 在这里可以是 通过注解方式（使用注解的或更加的灵活，但需要多创建一个相应的注解）
         *   ，也可以是直接通过判断class 的方式
         */
        return parameter.hasParameterAnnotation(UserLogined.class)//通过注解方式
                || parameter.getParameterType() == User.class;//直接判断 类型方式
    }
 
 
    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer
            , NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        /**
         * 到了这里说明 ：方法参数中有匹配的情况那么我们可以 获得用户了
         *  ，这里只是简单的演示，取用户的操作         
         */
         Object user  = webRequest.getNativeRequest(HttpServletRequest.class).
                     getSession().getAttribute("currentUser");
        //如果有必要的话，可以在 用户为空的情况下抛出异常
        /**
         * if(user==null){
         *    throw new UserNotFoundException();
         *   }
         */
        /**
         * Tips: 在自定义参数注入中，有时也需要在路径中取出参数的情况，就像使用@PathVariable一样，
         *  我们可以使用以下这行代码来取，Spring把路径中的参数和值封装到了一个Map里面
         *  ，并放进了Request中
         *  Map<String, String> uriTemplateVars =
         *      (Map<String, String>) webRequest.getAttribute(
         *      HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
         */
        return user;
    }
}

Ok 我们有了上面这个Resolver 后，就可以开始第二步了 将它交给Spring。

这里面提供两个版本的方式 第一种是常见的用到xml的方式，可以在 ServletContext.xml(Servlet级别的上下文) 中进行配置:

<?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:mvc="http://www.springframework.org/schema/mvc"
   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/mvc 
      http://www.springframework.org/schema/mvc/spring-mvc.xsd
      http://www.springframework.org/schema/context 
      http://www.springframework.org/schema/context/spring-context.xsd">
   <mvc:annotation-driven>
         <mvc:argument-resolvers>
              <bean class="com.myconpany.factory.LoginUserArugmentResolver"/>
         </mvc:argument-resolvers>
    </mvc:annotation-driven>
</beans>

还是一种就是Spring4.X 中通过class 来配置Sevlet相关信息的方式:

@EnableWebMvc@Configuration@EnableAspectJAutoProxy(proxyTargetClass = true)
@ComponentScan({"com.mycompany.controller"})
public class ServletContextBoot extends WebMvcConfigurerAdapter{
    @Override
    public void addArgumentResolvers (List<HandlerMethodArgumentResolver> argumentResolvers) {
        //此行 需要调用方法，这样Spring会帮你完成装配工作
        argumentResolvers.add(loginUserArugmentResolver());
    }
    @Bean
    public LoginUserArugmentResolver loginUserArugmentResolver() {
        return new LoginUserArugmentResolver();
    }
}

原文来自

文章目录
把参数写进默认文件里application.properties
直接注入，会直接把默认文件里prefix打头的文件加载进去，这样有个缺点就是都是完全载入。

把参数写进默认文件里application.properties

直接注入，会直接把默认文件里prefix打头的文件加载进去，这样有个缺点就是都是完全载入。

Spring DI 依赖注入案例（带参数构造方法依赖注入和setter方法依赖注入和p名称空间注入）


DI 依赖注入：
  简单的说是指对象中的属性的值设置方式不再是调用setter方法进行传值，而是由配置实现经过框架传值。
 
DI操作可以采用两种实现方案：
    1、使用带参构造实现注入
<!-- 采用带参构造的方式实现依赖注入 -->
<bean id="user" class="cn.sz.pojo.User">
<constructor-arg name="id" value="123"></constructor-arg>
</bean>

    2、使用setter方法实现注入
<!-- 采用setter方法实现依赖注入 -->
<bean id="user" class="cn.sz.pojo.User">
<property name="id" value="13"></property>
</bean>

补充：constructor和property标签中常用属性：name,value,ref
  name 设置类中的属性名
  value设置属性的具体值
  ref设置bean的id（及关联其它的配置项的id）





下面演示的是带参数构造方法依赖注入和setter方法依赖注入方式：

项目中SpringTest.java测试类使用junit方式测试即单元测试。lib目录下为测试中需要的spring jar包，log4j.jar为日志包，User.java是测试需要的一个实体类，applicationContext.xml为spring的主配置文件，名称可以任意但官方建议使用该默认名称。log4j.properties为日志配置文件。本案例使用的spring版本为
 spring4.3.9。




创建一个java项目，项目结构如下：










代码如下：

1、applicationContext.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">	
	<!--DI操作（依赖注入） -->
	<!-- 方式一采用带参构造的方式实现依赖注入 -->
	<bean id="user4" class="cn.sz.pojo.User">
		<constructor-arg name="id" value="123"></constructor-arg>
		<constructor-arg name="name" value="张三"></constructor-arg>
	</bean>

	<!-- 方式二：采用setter方法实现依赖注入 ，还演示了结合属性的依赖注入 -->
	<bean id="user5" class="cn.sz.pojo.User">
		<property name="id" value="456"></property>
		<property name="name" value="李四"></property>
		<!-- 数组属性依赖注入 -->
		<property name="strs">
			<array>
				<value>数组属性1</value>
				<value>数组属性2</value>
				<value>数组属性3</value>
			</array>
		</property>
		<!-- list集合属性依赖注入 -->
		<property name="list">
			<list>
				<value>list属性1</value>
				<value>list属性2</value>
				<value>list属性3</value>
			</list>
		</property>
		<!-- set集合属性依赖注入（set集合内容不能重复） -->
		<property name="set">
			<set>
				<value>set属性1</value>
				<value>set属性2</value>
				<value>set属性3</value>
			</set>
		</property>
		<!-- map集合属性依赖注入 -->
		<property name="map">
			<map>
				<entry key="key1" value="map集合属性1"></entry>
				<entry key="key2" value="map集合属性2"></entry>
				<entry key="key3" value="map集合属性3"></entry>

			</map>
		</property>

		<!--Properties属性依赖注入 -->
		<property name="properties">
			<props>
				<prop key="p1">Properties属性1</prop>
				<prop key="p2">Properties属性2</prop>
			</props>
		</property>
	</bean>
</beans>





2、log4j.properties （日志文件）





[plain] view
 plain copy





<span style="font-family:Microsoft YaHei;font-size:18px;">log4j.rootLogger=DEBUG,console,FILE  

log4j.appender.console=org.apache.log4j.ConsoleAppender  

log4j.appender.console.threshold=INFO  

log4j.appender.console.layout=org.apache.log4j.PatternLayout  

log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n  

log4j.appender.FILE=org.apache.log4j.RollingFileAppender  

log4j.appender.FILE.maxBackupIndex=100  

##log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender   

log4j.appender.FILE.Append=true  

log4j.appender.FILE.File=c:/error1.log  

log4j.appender.FILE.Threshold=INFO  

log4j.appender.FILE.layout=org.apache.log4j.PatternLayout  

log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n  

log4j.appender.FILE.MaxFileSize=1MB  

</span>  




3、SpringTest.java （junit测试类）
package cn.sz.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.sz.pojo.User;
public class SpringTest {
	// 方法一：使用带参构造方法实现依赖注入
	@Test
	public void testA() {
		// 读取主配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		User user4 = ac.getBean("user4", User.class);
		System.out.println(user4.toString());
	}

	// 方法二： 使用setter方法实现依赖注入
	@Test
	public void testB() {
		// 读取主配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		User user5 = ac.getBean("user5", User.class);
		System.out.println(user5.toString());
	}
}





4、User.java （用户实体类）


package cn.sz.pojo;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class User {
	private Integer id;
	private String name;
	private String[] strs;
	private List<String> list;
	private Set<String> set;
	private Map<String, String> map;
	private Properties properties;

	// 保留无参的构造方法
	public User() {

	}

	// 为了演示使用带参数构造的方式实现依赖注入所以提供一个带参的构造方法测试
	public User(Integer id, String name) {
		this.id = id;
		this.name = name;
	}

	// 下面的setter方法是测试使用setter方式依赖注入使用的
	public String[] getStrs() {
		return strs;
	}

	public void setStrs(String[] strs) {
		this.strs = strs;
	}

	public List<String> getList() {
		return list;
	}

	public void setList(List<String> list) {
		this.list = list;
	}

	public Set<String> getSet() {
		return set;
	}

	public void setSet(Set<String> set) {
		this.set = set;
	}

	public Map<String, String> getMap() {
		return map;
	}

	public void setMap(Map<String, String> map) {
		this.map = map;
	}

	public Properties getProperties() {
		return properties;
	}

	public void setProperties(Properties properties) {
		this.properties = properties;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", strs=" + Arrays.toString(strs) + ", list=" + list + ", set="
				+ set + ", map=" + map + ", properties=" + properties + "]";
	}

}


testA()测试结果：





testB()测试结果：




以上两种方式以及完成了依赖注入




接下来是名称空间注入：

只是在配置文件有所不同，其他用法和以上的方法一致：

applicationContext.xml




<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
   xmlns:user="http://www.springframework.org/schema/p"
    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">  
    <!-- 命名空间创建对象 -->  
   <bean id="user" class="cn.sz.pojo.User" user:uid="101" user:name="李四"></bean>  
</beans>



注：需要使用setter/getter方法


xmlns:user="http://www.springframework.org/schema/p"

user为任意的名称

<bean id="user" class="cn.sz.pojo.User" user:uid="101" user:name="李四"></bean>

bean中user是上面配置的user,名称一致