精华内容
下载资源
问答
  • Spring 依赖注入(DI)详解 [Spring][依赖注入的 6 种实现方式][setter注入][构造器注入][注解注入][自动装配注入][静态工厂注入][实例工厂注入],您的“关注”和“点赞”,是信任,是认可,是支持,是动力.........

    Spring 依赖注入(DI)详解 [Spring][依赖注入的 6 种实现方式][setter注入][构造器注入][注解注入][自动装配注入][静态工厂注入][实例工厂注入],您的“关注”和“点赞”,是信任,是认可,是支持,是动力......

    如意见相佐,可留言。

    本人必将竭尽全力试图做到准确和全面,终其一生进行修改补充更新。

    目录1 依赖注入概述

    2 依赖注入的多种方式(Bean 的装配方式)2.1 基于 XML 的依赖注入2.1.1 Setter Injection(设置方法注入)

    2.1.2 Constructor Injection(构造器注入)

    2.2 基于 Annotation(注解)的依赖注入2.2.1 基于 Annotation(注解)的依赖注入概述

    2.2.2 常用注解概述

    2.3.3 案例实操,走起

    2.3 基于自动装配的依赖注入

    2.4 静态工厂注入

    2.5 实例工厂注入

    【文章其他地址】微信公众号:码农阿杰

    CSDN 博客

    【参考资料】spring

    Artifact Repository Browser

    Apache Commons

    1 依赖注入概述

    依赖注入,英文叫做 Dependency Injection,简称 DI。

    DI 和 IoC (《Spring IoC 容器详解》)含义相同,它们是从两个角度描述的同一个概念、做同一件事情。

    当某个 Java 实例需要另一个 Java 实例时,使用 Spring 之前都是由调用者创建(使用 new 关键字获得被调用者实例)被调用者的实例,而使用 Spring 框架后,被调用者的实例不再由调用者创建,而是由 Spring IoC 容器创建,这称为控制反转,也即 IoC。

    Spring IoC 容器在创建被调用者的实例时,会自动将调用者需要的对象实例注入给调用者,这样,调用者通过 Spring IoC 容器获得被调用者实例,这称为依赖注入,也即 DI。

    Bean 的依赖注入方式,或叫 Bean 的装配方式,有多种形式,比如接下来要介绍的基于 XML 的依赖注入(有两种实现方式:Setter Injection 设置注入和 Constructor Injection 构造器注入)、基于 Annotation 的依赖注入、基于自动装配、基于静态工厂的方式的依赖注入和基于实例工厂的方式的依赖注入等。

    2 依赖注入的多种方式(Bean 的装配方式)

    2.1 基于 XML 的依赖注入

    2.1.1 Setter Injection(设置方法注入)

    基于设置方法注入,也可以叫做setter方法注入,这是最简单的注入方式。

    指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后,调用该 bean 的 setter 方法,即可实现基于 setter 的 DI。

    案例实操,走你!

    目的:在UserService接口的实现类UserServiceImpl中用setter方法初始化UserDao的对象。

    具体步骤如下所示,

    第一步:在com.manongajie.service包下创建UserService接口。如下图所示:

    64c2bc47893990a7fa63071e2d19f053.png

    第二步:在com.manongajie.serviceimpl包下创建接口UserService的实现类UserServiceImpl。在类中声明userDao变量,但是没有初始化它,这里就必须要 setter 方法(是 IoC 容器的注入入口。相当于 IoC 容器调用 setter 方法初始化 userDao 变量)了,如下图所示:

    efa070074f67b981805a1277185ec207.png

    第三步:在 applicationContext.xml配置文件中添加配置信息。标签中的 name属性值为setXxx()方法的参数(也叫依赖项);ref属性值为 Bean 的name或id值。添加内容,如下图所示:

    a357a6e5a26fc670bbbd98a791166951.png

    第四步:编写测试类并使用JUnit 测试运行。在com.manongajie.test包下的SpringTest类中创建test2()方法。如下图所示:

    f2266d2ea0e8b80159de6c4c40baf931.png

    从上图中可以看出,使用 Spring IoC 容器获取 userService的实例后,调用了该实例的 addUser()方法,在该方法中又调用了 UserDao 接口的实现类 UserDaoImpl 中的 save()方法(userDao 对象就是 IoC 容器自动调用 setter 方法注入的。本例中 setter 方法为 setUserDao() 方法)。

    2.1.2 Constructor Injection(构造器注入)

    指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法(本文本小节以带参数的构造器进行介绍)实现,每个参数代表一个依赖,Spring 容器会根据 bean 中指定的构造方法参数来决定调用哪个构造函数。

    案例实操,走你!

    目的:在UserDaoImpl类中创建成员变量userService,使用UserDaoImpl类的构造器注入userService 实例,也就是说 spring 容器在创建 UserDaoImpl类的实例时,也要将 userService实例作为构造器的参数值传到UserDaoImpl类中(配置文件中操作,使用标签,ref属性表示 Bean 的 id)。

    具体步骤如下所示,

    第一步:直接在之前的项目中操作,在UserDaoImpl类中创建一个成员变量userService,构造器UserService(UserService userService),如下图所示:

    2579efeba51e41a3958983537fd6257d.png

    第二步:配置配置文件,如下图所示:

    278397ff50c1a2868925a7ebe784f2af.png

    第三步:编写测试类和JUnit 测试运行。如下图所示:

    ff2d2c7279fa3e8c50c0934e5162a878.png

    从上图中可以看出,通过 Spring 容器获取UserDao的实例后,调用了该实例的save()方法,在该方法中又调用了UserService接口的实现类UserServiceImpl中的addUser()方法(userService 对象就是 spring 容器通过构造器注入的。)

    2.2 基于 Annotation(注解)的依赖注入

    2.2.1 基于 Annotation(注解)的依赖注入概述

    如果应用中 Bean 的数量较多,基于 XML 配置文件实现 Bean 的装配会导致 XML 配置文件过于臃肿,从而给维护和升级带来一定的困难。

    基于 Annotation(注解)的依赖注入就可以解决这个问题。

    2.2.2 常用注解概述

    @Component

    可以使用此注解描述 Spring 中的 Bean,但它是一个泛化的概念,仅仅表示一个组件(Bean),并且可以作用在任何层次。使用时只需将该注解标注在相应类上即可。

    @Repository

    用于将数据访问层(DAO层)的类标识为 Spring 中的 Bean,其功能与 @Component 相同。

    @Service

    通常作用在业务层(Service 层),用于将业务层的类标识为 Spring 中的 Bean,其功能与 @Component 相同。

    @Controller

    通常作用在控制层(如 Struts2 的 Action),用于将控制层的类标识为 Spring 中的 Bean,其功能与 @Component 相同。

    @Autowired(在本文 《2.3 基于自动装配的依赖注入》 小节详细介绍)

    用于对 Bean 的属性变量、属性的 Set 方法及构造函数进行标注,配合对应的注解处理器完成 Bean 的自动配置工作。默认按照 Bean 的类型进行装配。

    @Resource

    其作用与 Autowired 一样。其区别在于 @Autowired 默认按照 Bean 类型装配,而 @Resource 默认按照 Bean 实例名称进行装配。

    @Resource 中有两个重要属性:name 和 type。

    Spring 将 name 属性解析为 Bean 实例名称,type 属性解析为 Bean 实例类型。

    如果指定 name 属性,则按实例名称进行装配;

    如果指定 type 属性,则按 Bean 类型进行装配。

    如果都不指定,则先按 Bean 实例名称装配,如果不能匹配,则再按照 Bean 类型进行装配;如果都无法匹配,则抛出 NoSuchBeanDefinitionException 异常。

    @Qualifier

    与 @Autowired 注解配合使用,会将默认的按 Bean 类型装配修改为按 Bean 的实例名称装配,Bean 的实例名称由 @Qualifier 注解的参数指定。

    2.3.3 案例实操,走起

    第一步:导入关键 JAR 包。然后创建 DAO 层接口,在com.manongajie.dao包下创建PersonDao接口,并添加add()方法。如下图所示:

    a7a9c2e85f0b5d74acc63d402cfefbf8.png

    第二步:创建 DAO 层接口的实现类。在com.manongajie.daoimpl包下创建PersonDao接口的实现类PersonDaoImpl,并添加 DAO 层 add()方法。对类使用@Repository 注解将 PersonDaoImpl 类标识为 Spring 中的 Bean,其写法相当于配置文件中 的书写。如下图所示:

    2b02453791211d2ebf591049f83a0e9a.png

    第三步:创建 Service 层接口。图下图所示:

    3884e2c8390eeae072faba4a4751ad98.png

    第四步:创建 Service 层接口的实现类。如下图所示:

    c8a1237dc010a9245905fad8fec8d3a3.png

    第五步:创建 Action 控制层。如下图所示:

    6213421c56407893c8459b4f01fcd4b6.png

    第六步:创建 Spring 配置文件。需要添加更多的约束文件,如何把约束文件交给 Eclipse 管理,请参见博文《开启 Spring 之旅:第一个 Spring 程序 !》。

    8d827949aa24da90924657088784f173.png

    第七步:创建测试类和 JUnit 运行测试。如下图所示:

    c0b049d87a16d48a1c842af2d05f712f.png

    从上图中可以看出,DAO 层、Service 层和 Action 层的 add()方法都成功输出了结果。

    So,使用 Annotation 装配 Bean 的方式已经成功实现了。

    2.3 基于自动装配的依赖注入

    本文篇幅太长了,另写一文。

    请参见博文《Spring 基于自动装配的依赖注入详解》。

    2.4 静态工厂注入

    需要提供一个静态工厂方法 createBean(),创建 Bean 的实例(是指createBean()方法返回哪个类的实例,就创建哪个类的实例)。

    需要在配置文件中,使用 标签的 factory-method 属性,用于告诉 Spring 容器调用工厂类中的 createBean() 方法获取 Bean 的实例。

    案例演示,如下所示:

    第一步:创建实体类 Person。在com.manongajie.static_factory包下创建。

    7b968c0327e397b9aeafa0a9ef731972.png

    第二步:创建静态工厂类MyBeanFactory,并在类中创建createBean()静态方法,用于创建 Bean 的实例。

    601e8e26196415c131baf1d85261706b.png

    第三步:创建配置文件。

    1c6084e521f3ebc9d6d66a2b63e5b737.png

    第四步:创建测试类和JUnit 测试运行。

    821c122bb21cd2c987ff92d540579d34.png

    从以上运行结果可以看出,使用静态工厂的方式也成功对 Bean 进行了实例化。

    2.5 实例工厂注入

    使用这种方式,工厂类不再使用静态方法创建 Bean 的实例,而是直接在成员方法中创建 Bean 的实例。

    也就是说需要一个成员方法createBean()来创建 Bean 的实例。

    在配置文件中,需要实例化的 Bean 也不是通过 class 属性直接指向其实例化的类,而是通过 factory-bean 属性配置一个实例工厂,然后使用 factory-method 属性确定使用工厂中的哪个方法。

    案例演示,如下所示:

    第一步:创建实体类 Person,并在类中添加say()方法。

    ca600f8c3d591f7b7b86ea18d1d51bd3.png

    第二步:创建实例工厂类,并添加成员方法createBean()。

    80eb3e8314547c4aa239c5a6d496893b.png

    第三步:创建配置文件。

    b2bb79909d3dfe8045bfe30c7e3cb64a.png

    第四步:创建测试类和JUnit 测试运行。

    68a1f7d1763a0fee511ccd7b55aced66.png

    从以上运行结果可以看出,使用实例工厂的方式也是可以对 Bean 进行实例化的哦。。

    【文章其他地址】

    微信公众号:码农阿杰

    CSDN 博客

    【参考资料】

    spring

    Artifact Repository Browser

    Apache Commons

    相关文章暂无相关文章

    展开全文
  • 1. 确保该类被注入容器中,@Component 2. 确保有一个静态字段 3. 给静态字段写set方法..在set方法上设置@Autowired 4. 将 set方法中传入的值赋值给 Factory.字段名 @Component public class StaticFactory { @...
    注入静态字段:
    1. 设置注入  @Autowired修饰在Setter方法上
    2. 构造注入  @Autowired修饰在构造方法上
    3. 实例被创建后使用@PostConstructor修饰方法注入
    
    @Component
    public class JustAClass{
      private static Service service;
    
      @PostConstruct
      public void init() {
        service = tmpService;
      }
    }
    
    1. 确保该类被注入容器中,@Component
    2. 确保有一个静态字段
    3. 给静态字段写set方法..在set方法上设置@Autowired
    4. 将 set方法中传入的值赋值给 Factory.字段名
    
    @Component
    public class StaticFactory {
    
        @Autowired
        public  void setDataSource(DataSource dataSource) {
            StaticFactory.dataSource = dataSource;
        }
    
     private static   DataSource dataSource;
     ...
     }
    
    使用注解的时候
    @Bean注入静态工厂产生的变量,但是Bean的名字不能注册成一样的,会报错
    后面的Bean会覆盖掉前面的Bean。。。
    怎么判断他是后面的bean还是前面的bean:
    	感觉是根据文件名判断的 Factory1 就比 Factory2 先创建
    
    如果启动组件扫描,bean名称不同时,spring将尝试创建一个bean,即使该类的bean
    已经在spring.xml中定义了
    但是,如果在spring配置文件中定义的bean和自动发现的bean具有相同的名称,
    那么在组件扫描时,spring不会创建一个新的bean(不会创建还是创建被覆盖了?)
    
    
    静态工厂注入的bean虽然注入到容器中了,,你可以使用@Autowired注入,但是使用
    @Autowired他只会调用@bean标识的方法,静态工厂方法里面如果引用了其他对象,
    在注入的时候会出现其他对象空指针,直接使用 类名.方法名 获取实例
    

    引用:https://blog.csdn.net/tys87198312/article/details/103520503
    https://blog.csdn.net/molashaonian/article/details/79359489?utm_source=blogxgwz5
    https://blog.csdn.net/SnailMann/article/details/79965000

    展开全文
  • spring通过IOC容器帮我们管理了对象,但是管理的这些对象,当我们需要其中一个或者是多个的时候应该怎么样获取呢,这就和对象注入有关系了,通过注入,我们可以从spring容器中反向被动的获取对象,然后就可以使用...

    写在前面

    spring通过IOC容器帮我们管理了对象,但是管理的这些对象,当我们需要其中一个或者是多个的时候应该怎么样获取呢,这就和对象注入有关系了,通过注入,我们可以从spring容器中反向被动的获取对象,然后就可以使用这些对象的能力来完成我们的任务了。

    1:setter方法注入

    其实就是属性值入。

    1.1:定义注入的类

    public class MyDao {
    }
    

    1.2:定义被注入的类

    public class MyAction {
        private MyDao myDao;
    
        public MyDao getMyDao() {
            return myDao;
        }
    
        public void setMyDao(MyDao myDao) {
            this.myDao = myDao;
        }
    }
    

    1.3:定义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="myDao" class="yudaosourcecode.spring.MyDao"/>
        <bean id="myAction" class="yudaosourcecode.spring.MyAction">
            <property name="myDao" ref="myDao"/>
        </bean>
    </beans>
    

    1.4:测试

    @Test
    public void testDiBySetter() {
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        MyAction myAction = ac.getBean("myAction", MyAction.class);
        System.out.println("myAction.getMyDao(): ");
        System.out.println(myAction.getMyDao());
    }
    

    运行:

    myAction.getMyDao(): 
    yudaosourcecode.spring.MyDao@75881071
    

    2:构造器注入

    2.1:定义注入的类

    public class DiPerson {
    }
    public class DiUser {
    }
    

    2.2:定义被注入的类

    public class ConstructorDi {
        public DiPerson diPerson;
        public DiUser diUser;
    
        public ConstructorDi(DiPerson diPerson, DiUser diUser) {
            this.diPerson = diPerson;
            this.diUser = diUser;
        }
    }
    

    注意其中的private DiPerson diPersonprivate DiUser diUser我们没有定义读写方法。

    2.3:定义xml

    <beanid="myPerson" class="yudaosourcecode.spring.DiPerson"/>
    <bean id="myUser" class="yudaosourcecode.spring.DiUser"/>
    <bean id="constructorDi" class="yudaosourcecode.spring.ConstructorDi">
        <!--
        public ConstructorDi(DiPerson diPerson, DiUser diUser) {
            this.diPerson = diPerson;
            this.diUser = diUser;
        }
        -->
        <constructor-arg index="0" ref="myPerson"/>
        <constructor-arg index="1" ref="myUser"/>
    </bean>
    

    2.4:测试

    @Test
    public void diByConstructorTest() {
        ClassPathXmlApplicationContext ac
                = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        ConstructorDi constructorDi = ac.getBean("constructorDi", ConstructorDi.class);
        System.out.println("constructorDi.diPerson is: ");
        System.out.println(constructorDi.diPerson);
        System.out.println("constructorDi.diUser is: ");
        System.out.println(constructorDi.diUser);
    }
    

    输出:

    constructorDi.diPerson is: 
    yudaosourcecode.spring.DiPerson@7403c468
    constructorDi.diUser is: 
    yudaosourcecode.spring.DiUser@43738a82
    
    Process finished with exit code 0
    

    3:静态工厂方法注入

    这种方式其实是调用调用某个类的静态方法来获取需要需要的对象来进行注入。

    3.1:定义注入的类

    public class DiPerson {
    }
    

    3.2:定义静态工厂类

    该静态工厂类提供静态方法返回DiPerson对象:

    public class StaticFactoryCls {
    
        public static final DiPerson generatePersonDi() {
            return new DiPerson();
        }
    }
    

    3.3:定义被注入的类

    public class StaticFactoryMethodDi {
        private DiPerson diPerson;
    
        public DiPerson getDiPerson() {
            return diPerson;
        }
    
        public void setDiPerson(DiPerson diPerson) {
            this.diPerson = diPerson;
        }
    }
    

    3.4:定义xml

    <!-- 通过工厂方法定义bean -->
    <bean id="staticFactoryDiPerson" class="yudaosourcecode.spring.StaticFactoryCls" factory-method="generatePersonDi"/>
    <bean id="staticFactoryMethodDi" class="yudaosourcecode.spring.StaticFactoryMethodDi">
        <property name="diPerson" ref="staticFactoryDiPerson"/>
    </bean>
    

    3.5:测试

    staticFactoryMethodDi.getDiPerson() is: 
    yudaosourcecode.spring.DiPerson@67b467e9
    
    Process finished with exit code 0
    

    4:实例工厂方法注入

    这种方式和静态工厂方法注入的唯一区别就是生成对象的方法是实例方法,而不是静态方法。

    4.1:定义注入的类

    public class DiPerson {
    }
    

    4.2:定义实例工厂类

    public class InstanceFactoryCls {
        public DiPerson generatePersonDi() {
            return new DiPerson();
        }
    }
    

    注意这里的方法是实例方法,而不是静态方法了。

    4.3:定义被注入的类

    public class InstanceFactoryMethodDi {
        private DiPerson diPerson;
        public DiPerson getDiPerson() {
            return diPerson;
        }
    
        public void setDiPerson(DiPerson diPerson) {
            this.diPerson = diPerson;
        }
    
    }
    

    4.4:定义xml

    <!-- 定义实例工厂bean -->
    <bean id="instanceFactoryCls" class="yudaosourcecode.spring.InstanceFactoryCls"/>
    <!-- 通过实例工厂bean获取需要DI的bean -->
    <bean id="instanceFactoryDiPerson"
          factory-bean="instanceFactoryCls"
          factory-method="generatePersonDi"/>
    <bean id="instanceFactoryMethodDi" class="yudaosourcecode.spring.InstanceFactoryMethodDi">
        <property name="diPerson" ref="instanceFactoryDiPerson"/>
    </bean>
    

    4.5:测试

    @Test
    public void diByInstanceFactoryTest() {
        ClassPathXmlApplicationContext ac
                = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        InstanceFactoryMethodDi instanceFactoryMethodDi = ac.getBean("instanceFactoryMethodDi", InstanceFactoryMethodDi.class);
        System.out.println("instanceFactoryMethodDi.getDiPerson() is: ");
        System.out.println(instanceFactoryMethodDi.getDiPerson());
    }
    

    运行:

    instanceFactoryMethodDi.getDiPerson() is: 
    yudaosourcecode.spring.DiPerson@5c072e3f
    
    Process finished with exit code 0
    
    展开全文
  • 1. 使用静态工厂方法创建Bean使用静态工厂方法创建Bean...另外,还需要使用factory-method来指定静态工厂方法名,Spring将调用静态工厂方法(可能包含一组参数),来返回一个Bean实例,一旦获得了指定Bean实例,Sprin...

    1. 使用静态工厂方法创建Bean

    使用静态工厂方法创建Bean实例时,class属性也必须指定,但此时class属性并不是指定Bean实例的实现类,而是静态工厂类。因为Spring需要知道是用哪个工厂来创建Bean实例。另外,还需要使用factory-method来指定静态工厂方法名,Spring将调用静态工厂方法(可能包含一组参数),来返回一个Bean实例,一旦获得了指定Bean实例,Spring后面的处理步骤与采用普通方法创建Bean实例则完全一样。需要注意的是,当使用静态工厂方法来创建Bean时,这个factory-method必须要是静态的。这段阐述听上去有点晕,话不多说,上代码:

    先定义一个接口,静态方法产生的将是该接口的实例:

    public interface Animal {

    public void sayHello();

    }

    下面是接口的两个实现类:

    public class Cat implements Animal {

    private String msg;

    //依赖注入时必须的setter方法

    public void setMsg(String msg){

    this.msg = msg;

    }

    @Override

    public void sayHello(){

    System.out.println(msg + ",喵~喵~");

    }

    }

    public class Dog implements Animal {

    private String msg;

    //依赖注入时必须的setter方法

    public void setMsg(String msg){

    this.msg = msg;

    }

    @Override

    public void sayHello(){

    System.out.println(msg + ",旺~旺~");

    }

    }

    下面的AnimalFactory工厂中包含了一个getAnimal的静态方法,该方法将根据传入的参数决定创建哪个对象。这是典型的静态工厂设计模式。

    public clas AnimalFactory {

    public static Animal getAnimal(String type){

    if ("cat".equalsIgnoreCase(type)){

    return new Cat();

    } else {

    return new Dog();

    }

    }

    }

    如果需要指定Spring使用AnimalFactory来产生Animal对象,则可在Spring配置文件中作如下配置:

    从上面的配置可以看出:cat和dog两个Bean配置的class和factory-method完全相同,这是因为两个实例都使用同一个静态工厂类、同一个静态工厂方法产生得到的。只是为这个静态工厂方法指定的参数不同,使用元素来为静态工厂方法指定参数。

    主程序获取cat和dog两个Bean实例的方法不变,同样只需要调用Spring容器的getBean()即可:

    public class Test {

    public static void main(String args[]){

    ApplicationContext context =

    new ClassPathXmlApplicationContext("applicationContext.xml");

    Animal a1 = context.getBean("cat", Animal.class);

    a1.sayHello();

    Animal a2 = context.getBean("dog", Animal.class);

    a2.sayHello();

    }

    }

    输出结果:

    猫猫,喵~喵~

    狗狗,旺~旺~

    使用静态工厂方法创建实例时必须提供工厂类和产生实例的静态工厂方法。通过静态工厂方法创建实例时需要对Spring配置文件做如下改变;

    class属性不在是Bean实例的实现类,而是生成Bean实例的静态工厂类

    使用factory-method指定生产Bean实例的静态工厂方法

    如果静态工厂方法需要参数,使用元素为其配置

    当我们指定Spring使用静态工厂方法来创建Bean实例时,Spring将先解析配置文件,并根据配置文件指定的信息,通过反射调用静态工厂类的静态工厂方法,并将该静态工厂方法的返回值作为Bean实例,在这个过程中,Spring不再负责创建Bean实例,Bean实例是由用户提供的静态工厂方法提供的。

    2. 使用实例工厂方法创建Bean

    实例工厂方法与静态工厂方法只有一点不同:调用静态工厂方法只需要使用工厂类即可,调用实例工厂方法则必须使用工厂实例。所以在Spring配置上也只有一点区别:配置静态工厂方法指定静态工厂类,配置实例工厂方法则指定工厂实例。同样是上面的例子将AnimalFactory修改为:

    public clas AnimalFactory {

    public Animal getAnimal(String type){  //这里仅仅是去掉了static关键字

    if ("cat".equalsIgnoreCase(type)){

    return new Cat();

    } else {

    return new Dog();

    }

    }

    }

    Spring文件修改为:

    测试类不用修改,输出结果和上面相同。

    展开全文
  • //非静态方法 public Car createCar(){ Car car = new Car(); car.setBrand("BMW"); return car; } //静态方法 public static Car createStaticCar(){ Car car = new Car(); return car; } } 1.对
  • 五、依赖注入工厂设计模式总结 Java Spring中的依赖注入工厂设计模式 工厂模式与依赖注入之间的区别 5.1 工厂模式增加了对象,工厂和依赖关系之间的耦合。对象不仅需要依赖对象才能正常工作,还需要Factory对象...
  • 展开全部一、Set注入二、构造器注入三、静态工厂的e68a8462616964757a686964616f31333365633863方法注入内容拓展:一、Set注入1、这是最简单的注入方式,假设有一个SpringAction,类中需要实例化一个SpringDao对象,...
  • 独立的集合bean在多个bean之间可共享该独立bean。示例:在其他bean中即可共享该mycars--bean。P名空间使用p命名空间时需要先声明使用对应的命名...示例:静态工厂注入使用的是工厂中的静态方法。在service层引用的d...
  • 运用工厂静态,实例工厂)3.1:编写静态,实例工厂3.2:spring注入工厂3.3:测试输出: 0.项目结构 1.新建spring项目 1.1:选择使用maven,选择quicktart模板,一路next 1.2:导入依赖: 嫌麻烦的可以直接导入...
  • spring注入static属性

    2021-11-11 23:41:45
    所以,我们需要静态注入类或者属性。 坑: 如果你使用这样的注入方式的话,都是null,注入不进去。 @Autowired private static TestService testService; @Resource private static TestService testService; @Value...
  • 一、Spring DI(依赖注入)的实现方式:属性注入和构造注入 控制反转(Inversion of Control),即创建被调用者的实例不是由调用者完成,而是由Spring容器完成,并注入调用者。当应用了loc,一个对象依赖的其它对象会...
  • Spring注入方式有哪些

    2021-03-21 08:58:14
    Spring配置文件中使用XML文件进行配置,实际上是让Spring执行了相应的代码,例如:使用元素,实际上是让Spring执行无参或有参构造器使用元素,实际上是让Spring执行一次setter方法但Java程序还可能有其他类型的...
  • Spring IOC 手动注入

    2021-11-02 14:57:20
    Spring IOC 注入 主动实例化 1.设置配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...
  • 上一篇,用 setter 方式举例说明了 Spring 中的依赖注入支持的数据类型。 这篇,看看依赖注入的实现方式。 首先,bean 的配置文件可以通过 xml 和 properties 两种方式。其中 xml 是主流,properties 基本不用...
  • Spring bean的注入方式

    2021-01-11 18:35:27
    Spring bean注入方式 Car对象 //Car对象 public class Car { // 只包含基本数据类型的属性 private int speed; private double price; public Car() { } public Car(int speed, double price) { this.speed...
  • IOC操作bean管理 目前创建项目后文件目录: ...这次下载的是5.2.6版本,用到了四个spring的jar包,是ioc需要的至少四个,直接jar包复制后新建lib文件夹,再粘贴到目录下,再手动添加jar包: spring的官网地址: ...
  • 在装配对象的时候,将Spring中定义的对象注入到配置文件属性中 (3)IOC与DI的关系 实现IOC思想需要DI做支持 (4)IOC与DI的区别 IOC 和 DI 两者的本质是一样的,都是为了降低组件和组件间的耦合性 描述角度不同 IOC:组件...
  • Dependency Injection是spring框架核心 ioc 的具体实现。程序在编写时通过控制...依赖注入作用是在使用Spring框架创建对象时,动态的将其所依赖的对象注入到Bean组件中,其实现方式通常有两种一种是属性setter方法注
  • Spring工厂创建复杂对象 2. Spring工厂创建复杂对象的3种方式 2.1 FactoryBean接口 2.1.1 开发步骤 实现FactoryBean接口 FactoryBean接口有三个方法需要被实现 Object getObject() : 用于书写创建复杂对象的代码...
  • 一、Set注入这是最简单的注入方式,假设有一个SpringAction,类中需要实例化一个SpringDao对象,那么就可以定义一个private的SpringDao成员变量,然后创建SpringDao的set方法(这是ioc的注入入口):随后编写spring的...
  • 五、依赖注入工厂设计模式总结 Java Spring中的依赖注入工厂设计模式 工厂模式与依赖注入之间的区别 5.1 工厂模式增加了对象,工厂和依赖关系之间的耦合。对象不仅需要依赖对象才能正常工作,还需要Factory对象...
  • 而在Spring依赖注入(DI) (如下边) DataSource对象时,用的却是DruidDataSource,而 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="user
  • Spring中bean的四中注入方法 Set方法注入 如果我们需要使用set注入,那么必须要为属性提供set方法,Spring容器就是通过调用bean的set方法为属性注入值的。而在xml文件中,使用set注入的方式就是通过property标签 <...
  • Spring容器中支持的依赖注入方式主要有属性注入、构造函数注入工厂方法注入。接下来将为大家详细介绍这三种依赖注入的方式以及它们的具体配置方法。1.属性注入属性注入即通过setXXX( )方法注入bean的属性值...
  • 1.set方法注入 2.构造方法注入 3.xml注入 xml上填类似的值以后 4.接口注入 5.autowired 注解注入方式 6.resource 注解注入方式
  • 本文内容来自《小马哥讲Spring核心编程思想》,看完之后总结的笔记,适合闲暇时候看看 依赖注入的模式和类型 依赖注入的模式 手动模式 - 配置或者编程的方式,提前安排注入规则 XML 资源配置元信息 Java 注解配置...
  • Spring 依赖注入(xml配置文件方式演示) 应用程序中,通过对象协作来实现一个目标功能的现象非常普遍。 越复杂的程序,涉及到的对象会越多,对象与依赖对象之间的耦合性也会愈加复杂。 通过依赖注入取代手动处理...
  • XML配置:set注入、构造函数注入,P标签,静态工厂方法与实例工厂方法; 注解方式: @Autowired,@Resource,@Required。 案例 /** * 书 * * @author zrj * @date 2020/12/16 * @since V1.0 **/ public class ...
  • Spring容器中支持的依赖注入方式主要有属性注入、构造函数注入工厂方法注入。接下来将为大家详细介绍这三种依赖注入的方式以及它们的具体配置方法。 1、属性注入 属性注入即通过setXXX( )方法注入bean的属性值或...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,649
精华内容 12,259
关键字:

spring静态工厂注入

spring 订阅