本文目录
- 用javascript代码通俗的解释一下什么叫依赖注入
- spring依赖注入，和控制反转用自己的话说是怎么说的最好能够用代码来解释
- spring 中依赖注入有哪几种注解
- spring ioc依赖注入有几种 每种区别，优缺点
- Spring3.0框架中依赖注入主要有几种方式
- Spring依赖注入的两种方式是（ ）和（ ）
- spring的注入和直接new一个对象有什么不同
- spring依赖注入使用的什么设计模式
- 如何在程序中使用依赖注入
- 请问下依赖注入的三种方式的区别
用javascript代码通俗的解释一下什么叫依赖注入
首先必须了解依赖。依赖就是指B类要用A类的方法(或属性)，就称B依赖于A，那要调用方法肯定得有一个对象呀！
要解决从“没对象”到“有对象”的问题，有三种方式：
程序猿嘛，自己new一个
构造函数传入
setter函数传入
其中第一种自给自足，自己生产依赖的东西。。。。后两种是靠别人给的，别人把依赖的东西“注入”给你。后两种方式的过程就叫做“依赖注入”了。。。
// A类，假设有人需要它
function A() {}
A.prototype.hello = function() { console.log(“This is a“); }
// 自给自足的B类
function B() {}
B.prototype.talk = function() {
var a = new A();
a.hello();
}
new B().talk();
// 通过构造函数“注入”对象的B1类
function B1(a) { this.a = a; }
B1.prototype.talk = function() {
if (this.a) {
this.a.hello();
}
}
var a1 = new A();
new B1(a1).talk();
// 通过setter函数“注入”对象的B2类
function B2() { this.a = null; }
B2.prototype.setA = function(a) { this.a = a; }
B2.prototype.talk = function() {
if (this.a) {
this.a.hello();
}
}
var a2 = new A();
var b2 = new B2();
b2.setA(a2)
b2.talk();
总结，“依赖注入”就是需要什么对象，自己不去创建，而是把创建的过程放在了自己的外部。-javas
有一些依赖注入框架，你可以声明需要的是什么对象，然后由框架来创建并注入给你。
spring依赖注入，和控制反转用自己的话说是怎么说的最好能够用代码来解释
spring的依赖注入（DI）和控制反转(IOC)其实是一个概念。简单的说就是“你不用来找我，我会去找你”。就是我们在用对象的初始化是在我们用对象的时候有系统自动初始化，而不是我们显式的去做这项工作。依赖注入的方法有三种，其中最常用的是setter方法注入。给你举个例子吧。
假设有一个接口A和它的实现Aimpl。我们在B类中需要用到Aimpl。在IOC之前情况下我们会这么写
B{
A a=new Aimpl();
//其他代码
}
现在，有了IOC之后只需要
B{
A a;
//其他代码
public void setA(A a) {
this.a = a;
}
}
当然要在spring的配置文档applicationContext中配置A的bean
相关资料可以参考下spring的书
-java
spring 中依赖注入有哪几种注解
Spring对于Bean的依赖注入，支持多种注解方式：
@Resource
javax.annotation
JSR250 (Common Annotations for Java)
@Inject
javax.inject
JSR330 (Dependency Injection for Java)
@Autowired
org.springframework.bean.factory
Spring
直观上看起来，@Autowired是Spring提供的注解，其他几个都是JDK本身内建的注解，Spring对这些注解也进行了支持。但是使用起来这三者到底有什么区别呢？笔者经过方法的测试，发现一些有意思的特性。总结如下：
1. @Autowired有个required属性，可以配置为false，这种情况下如果没有找到对应的bean是不会抛异常的。@Inject和@Resource没有提供对应的配置，所以必须找到否则会抛异常。
2. @Autowired和@Inject基本是一样的，因为两者都是使用AutowiredAnnotationBeanPostProcessor来处理依赖注入。但是@Resource是个例外，它使用的是CommonAnnotationBeanPostProcessor来处理依赖注入。当然，两者都是BeanPostProcessor。
-javas
spring ioc依赖注入有几种 每种区别，优缺点
spring的核心思想是IOC和AOP，IOC-控制反转，是一个重要的面向对象编程的法则来消减计算机程序的耦合问题，控制反转一般分为两种类型，依赖注入和依赖查找，依赖什么？为什么需要依赖？注入什么？控制什么？依赖注入和控制反转是一样的概念吗？接触新的知识，小编的脑袋中全是大大的问号，不过没有关系，今天这篇博文，小编主要来简单的介绍一下在spring IOC中依赖注入的方法。-java
依赖注入和控制反转，目的是为了使类与类之间解耦合，提高系统的可扩展性和可维护性。我们可以从以下几个方面理解：
a、参与者都有谁？
b、依赖：谁依赖谁？为什么需要依赖？
c、注入：谁注入谁？又注入了什么呢？
d、控制反转：谁控制谁？控制什么？为什么叫反转呢？存在正转吗？-javas
e、控制反转和依赖注入是同一个概念吗？我们需要弄明白上面的问题，这样对于控制反转和依赖注入的理解有大大的帮助。
首先：第一个问题，参与者都有谁？
1）对象
2）IOC/DI容器
3）某个对象的外部资源
第二问题：依赖，谁依赖谁？为什么需要依赖？
依赖嘛，很好理解的，对象依赖于IOC/DI容器，至于为什么要依赖呢？对象需要IOC/DI容器来提供对象需要的外部资源。
第三个问题：注入，谁注入谁？又注入了什么呢？
显而易见是IOC/DI容器注入对象，注入了what呢？肯定注入的是某个需要的东西那就是注入对象所需要的资源，肯定不会注入无关紧要的内容，你说呢？
第四个问题：控制反转，谁控制谁？控制什么？为什么叫反转呢？存在正转吗？
控制反转，控制什么？肯定是IOC/DI容器控制对象，主要是控制对象实例的创建，反转是相对于正向而言的，那么什么算是正向的呢？考虑一下常规情况下的应用程序，如果要在A里面使用C，你会怎么做呢？当然是直接去创建C的对象，也就是说，是在A类中主动去获取所需要的外部资源C，这种情况被称为正向的。那么什么是反向呢？就是A类不再主动去获取C，而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中。-java
第五个问题：控制反转和依赖注入式同一个概念吗？
依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。-javas
了解了这些基本的概念，弄明白她们之间的联系和区别，能够帮助我们更好的理解，接着小编来重点介绍一下依赖注入，在spring ioc中有三种依赖注入，分别是：
a、接口注入；
b、setter方法注入；
c、构造方法注入；
接着小编对这三种注入方式一一进行讲解，通过demo的讲解，希望能够帮助小伙伴们更好的理解，不足之处还请多多指教。
接口注入
public class ClassA {
private InterfaceB clzB;
public void doSomething() {
Ojbect obj = Class.forName(Config.BImplementation).newInstance();
clzB = (InterfaceB)obj;
clzB.doIt();
}
……
}
解释一下上述的代码部分，ClassA依赖于InterfaceB的实现，我们如何获得InterfaceB的实现实例呢？传统的方法是在代码中创建 InterfaceB实现类的实例，并将赋予clzB.这样一来，ClassA在编译期即依赖于InterfaceB的实现。为了将调用者与实现者在编译期分离，于是有了上面的代码。我们根据预先在配置文件中设定的实现类的类名(Config.BImplementation),动态加载实现类，并通过InterfaceB强制转型后为ClassA所用，这就是接口注入的一个最原始的雏形。-java
setter方法注入
setter注入模式在实际开发中有非常广泛的应用，setter方法更加直观，我们来看一下spring的配置文件：
《?xml version=“1.0“ encoding=“UTF-8“?》
《beans xmlns=“
Spring3.0框架中依赖注入主要有几种方式
3种方法
1。构造器注入
public class xx {
private Manager manage;
public xx(Manager manage){
this.manage= manage;
}
}
2.setter 方法注入
public class xx {
private Manager manage;
public void setManager(Manager manage){
this.manage= manage;
}
}
3.接口注入
public interface Manager{
public void manage(Business business);
}
public class xx {
private Business business;
public void manage(Business business){
this.business = business;
}
}
-javas
Spring依赖注入的两种方式是（ ）和（ ）
1、Spring通过DI（依赖注入）实现IOC（控制反转），常用的注入方式主要有三种：构造方法注入，setter注入，基于注解的注入。
2、如果题目里只有两个空，那就是setter注入（也就是通过配置文件）和注解注入。
setter注入的写法（配置文件）
《!-- 注册userService --》
《bean id=“userService“ class=“com.lyu.spring.service.impl.UserService“》
《!-- 写法一 --》
《!-- 《property name=“UserDao“ ref=“userDaoMyBatis“》《/property》 --》
《!-- 写法二 --》
《property name=“userDao“ ref=“userDaoMyBatis“》《/property》
《/bean》
《!-- 注册mybatis实现的dao --》
《bean id=“userDaoMyBatis“ class=“com.lyu.spring.dao.impl.UserDaoMyBatis“》《/bean》
基于注解的注入-java
@Resource
@Qualifier(“userDaoMyBatis“)
private IUserDao userDao;
spring的注入和直接new一个对象有什么不同
一、意思不同
spring依赖注入，是指对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。
例如：
A对象需要引用B对象的话，可以在A的构造函数里面将B传递进去，或者调用A的某个set方法。
通俗一点就是spring已经new好了， 要用直接取拿。
二、顺序
new一个对象的时候，初始化顺序是：
父类静态块，子类静态块，父类属性（先系统默认值，后直接你赋予的值） ，父类构造器，子类属性，子类构造器。
三、要求
Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理，依赖注入通常有三种：
1、 set设值注入
2、构造方法注入
3、spring注解注入
spring依赖注入使用的什么设计模式
依赖注入模式
依赖注入(Dependency Injection) 是一个非常简单的概念，伸手-等待。
如例程1-1所示，Client依赖于抽象类型(甚至是具体类) IServer，蛋是(1)Client的类体中不创建IServer(子类)的对象，它不想自己创建IServer对象，而是提供public的构造器Client(IServer)或设置方法setIServer (IServer)等(伸手)，（2）坐等外界将初始化后的IServer对象(的引用)传递进来(等待)。
换言之，依赖注入模式是指客户类Client不用自己来初始化它所依赖的成员变量IServer，而是等待某个对象创建IServer的适当的(实现类）的对象并将它赋值给Client的成员变量。
依赖注入的意义，在于保证Client仅仅与(通常是接口或抽象类)IServer耦合，而不与IServer的子类型耦合，这样的程序符合OCP或依赖于抽象类型原则。
例程 1-1
package creational;
import java.lang.reflect.*; //也可以自己写
import tool.God;
public class Client{
private IServer s;
/**
* 依赖注入
*/
public Client(IServer s){
this.s = s;
}
public void setS(IServer s){
this.s = s;
}
public static void test(){
//使用工具God
IServer s = (IServer) God.create(“1-5“);
s.m();
}
}
-javas
如何在程序中使用依赖注入
依赖注入分为三种。
set注入，最常用的，需要在对应的类中声明一个本类的对象，然后添加set方法。通过Spring的配置bean来实例化它。
还有构造器注入，需要添加构造器，默认的是无参的，可以重载构造器，然后在配置文件中配置好constructer标签。注意参数的顺序。
再就是接口注入，ref引用其他配置好的bean。~
-java
请问下依赖注入的三种方式的区别
Type1 接口注入
我们常常借助接口来将调用者与实现者分离。如：
public class ClassA {
private InterfaceB clzB;
public init() {
Ojbect obj =
Class.forName(Config.BImplementation).newInstance();
clzB = (InterfaceB)obj;
}
……
}
上面的代码中，ClassA依赖于InterfaceB的实现，如何获得InterfaceB实现类的实例？传统的方法是在代码中创建InterfaceB实现类的实例，并将起赋予clzB。
而这样一来，ClassA在编译期即依赖于InterfaceB的实现。为了将调用者与实现者在编译期分离，于是有了上面的代码，我们根据预先在配置文件中设定的实现类的类名，动态加载实现类，并通过InterfaceB强制转型后为ClassA所用。
这就是接口注入的一个最原始的雏形。
而对于一个Type1型IOC容器而言，加载接口实现并创建其实例的工作由容器完成，如J2EE开发中常用的Context.lookup（ServletContext.getXXX），都是Type1型IOC的表现形式。
Apache Avalon是一个典型的Type1型IOC容器。
Type2构造子注入
构造子注入，即通过构造函数完成依赖关系的设定，如：
public class DIByConstructor {
private final DataSource dataSource;
private final String message;
public DIByConstructor(DataSource ds, String msg) {
this.dataSource = ds;
this.message = msg;
}
……
}
可以看到，在Type2类型的依赖注入机制中，依赖关系是通过类构造函数建立，容器通过调用类的构造方法，将其所需的依赖关系注入其中。
PicoContainer（另一种实现了依赖注入模式的轻量级容器）首先实现了Type2类型的依赖注入模式。
Type3设值注入
在各种类型的依赖注入模式中，设值注入模式在实际开发中得到了最广泛的应用（其中很大一部分得力于Spring框架的影响）。
在笔者看来，基于设置模式的依赖注入机制更加直观、也更加自然。Quick Start中的示例，就是典型的设置注入，即通过类的setter方法完成依赖关系的设置。
几种依赖注入模式的对比总结
接口注入模式因为具备侵入性，它要求组件必须与特定的接口相关联，因此并不被看好，实际使用有限。
Type2 构造子注入的优势：
1、“在构造期即创建一个完整、合法的对象”，对于这条Java设计原则，Type2无疑是最好的响应者。
2、避免了繁琐的setter方法的编写，所有依赖关系均在构造函数中设定，依赖关系集中呈现，更加易读。
3、由于没有setter方法，依赖关系在构造时由容器一次性设定，因此组件在被创建之后即处相对“不变”的稳定状态，无需担心上层代码在调用过程中执行setter方法对组件依赖关系产生破坏，特别是对于Singleton模式的组件而言，这可能对整个系统产生重大的影响。
4、同样，由于关联关系仅在构造函数中表达，只有组件创建者需要关心组件内部的依赖关系。对调用者而言，组件中的依赖关系处于黑盒之中。对上层屏蔽不必要的信息，也为系统的层次清晰性提供了保证。
5、通过构造子注入，意味着我们可以在构造函数中决定依赖关系的注入顺序，对于一个大量依赖外部服务的组件而言，依赖关系的获得顺序可能非常重要，比如某个依赖关系注入的先决条件是组件的DataSource及相关资源已经被设定。
Type3设值注入的优势
1、对于习惯了传统JavaBean开发的程序员而言，通过setter方法设定依赖关系显得更加直观，更加自然。
2、如果依赖关系（或继承关系）较为复杂，那么Type2模式的构造函数也会相当庞大（我们需要在构造函数中设定所有依赖关系），此时Type3模式往往更为简洁。
3、对于某些第三方类库而言，可能要求我们的组件必须提供一个默认的构造函数（如Struts中的Action），此时Type2类型的依赖注入机制就体现出其局限性，难以完成我们期望的功能。
可见，Type2和Type3模式各有千秋，而Spring、PicoContainer都对Type2和Type3类型的依赖注入机制提供了良好支持。这也就为我们提供了更多的选择余地。理论上，以Type2类型为主，辅之以Type3类型机制作为补充，可以达到最好的依赖注入效果，不过对于基于Spring Framework开发的应用而言，Type3使用更加广泛。
-javas
