spring创建bean的三种方式

1、使用构造器创建bean

1.1、使用无参构造器创建

package com.ly.spring;
public class Person {
    private String name;
    public void say(String name) {
        System.out.println("你好,我叫"+name);
    }
}
<?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="person" class="com.ly.spring.Person"></bean>
</beans>

1.2、使用有参构造器创建

package com.ly.spring;
public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public void say() {
        System.out.println("我的名字叫"+this.name);
    }
}
<?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="person" class="com.ly.spring.Person">
    <!--指定构造器对应参数名对应的值-->
    <constructor-arg name="name" value="有参构造"></constructor-arg>
</bean>
</beans>

2、使用静态工厂方法创建bean

Person:

package com.ly.spring;
public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public void say() {
        System.out.println("我的名字叫"+this.name);
    }
}

Chinese:

package com.ly.spring;
public class Chinese implements Person {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void say() {
        System.out.println("我的名字叫"+this.name);
    }
}

American:

package com.ly.spring;
public class American implements Person {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void say() {
        System.out.println("我的名字叫"+this.name);
    }
}

工厂类PersonFactory:

package com.ly.spring;
public class PersonFactory {
    public static Person getPerson(String name) {
        if("Chinese".equals(name)) {
            return new Chinese();
        }else if("American".equals(name)) {
            return new American();
        }
        return null;
    }
}

配置文件:

<?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">
    <!--
    class指定工厂类类路径
    factory-method指定工厂类的静态方法
    -->
    <bean id="chinese" class="com.ly.spring.PersonFactory"  factory-method="getPerson">
        <!--给工厂的静态方法注入参数-->
        <constructor-arg name="name" value="Chinese"></constructor-arg>
        <!--通过set方法给Chinese类的name属性注入值-->
        <property name="name" value="中国人"></property>
    </bean>
    <bean id="american" class="com.ly.spring.PersonFactory" factory-method="getPerson">
        <constructor-arg name="name" value="American"></constructor-arg>
        <property name="name" value="美国人"></property>
    </bean>
</beans>

测试类:

package com.ly.spring.test;
import com.ly.spring.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Person p1 = context.getBean("chinese", Person.class);//获取到的其实是Chinese类
        p1.say();//执行时会调用Chinese类的方法
        Person p2 = context.getBean("american",Person.class);//获取到的其实是American类
        p2.say();//执行时会调用American类的方法
    }
}

3、使用实例工厂方法创建bean

修改后的工厂类PersonFactory:

package com.ly.spring;
public class PersonFactory {
    //这里不再是静态方法
    public Person getPerson(String name) {
        if("Chinese".equals(name)) {
            return new Chinese();
        }else if("American".equals(name)) {
            return new American();
        }
        return null;
    }
}

修改后的配置文件:

<?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-->
    <bean id="personFactory" class="com.ly.spring.PersonFactory"></bean>
    <!--
    factory-bean指定配置的工厂bean
    factory-method指定工厂类的实例方法
    -->
    <bean id="chinese" factory-bean="personFactory" factory-method="getPerson">
        <!--给工厂的实例方法注入参数-->
        <constructor-arg name="name" value="Chinese"></constructor-arg>
        <!--通过set方法给Chinese类的name属性注入值-->
        <property name="name" value="中国人"></property>
    </bean>
    <bean id="american" factory-bean="personFactory" factory-method="getPerson">
        <constructor-arg name="name" value="American"></constructor-arg>
        <property name="name" value="美国人"></property>
    </bean>
</beans>

原文地址:https://www.cnblogs.com/liuyang-520/p/12330640.html

时间: 2024-07-30 17:04:58

spring创建bean的三种方式的相关文章

Spring笔记——4.创建Bean的三种方式

Spring支持使用如下三种方法创建Bean: 调用构造器创建Bean 调用静态工厂方法创建Bean 调用实例工厂方法创建Bean 构造器 这是最常见的,框架底层调用bean的无参数构造器.这种情况下,class助兴是必需的.之前写的都是这种方式. 静态工厂方法创建Bean class也必须指定,但不是指定实现类,而是静态工厂类,这个工厂会创建bean实例.另外还需要factory-method指定用哪个方法创建bean实例,返回值即为实例. 接口与实现类如下: public interface

spring 装配bean的三种方式

这段时间在学习Spring,依赖注入DI和面向切面编程AOP是Spring框架最核心的部分.这次主要是总结依赖注入的bean的装配方式. 什么是依赖注入呢?也可以称为控制反转,简单的来说,一般完成稍微复杂的业务逻辑,可能需要多个类,会出现有些类要引用其他类的实例,也可以称为依赖其他类.传统的方法就是直接引用那个类对象作为自己的一个属性,但如果我们每次创建这个类的对象时,都会创建依赖的类的对象,还有如果那个类将来可能不用了,还需要到这个类去删除这个对象,那破坏了代码的复用性和导致高度耦合! 依赖注

Spring 实例化bean的三种方式

第一种方法:直接配置Bean Xml代码   <bena id="所需要实例化的一个实例名称" class="包名.类名"/> 例如: 配置文件中的bean.XML代码: Xml代码   <bean id="userA" class="com.test.User"/> Java代码   package com.test public class User{ public void test(){ Sys

Spring 创建Bean的6种方式

前言 本文讲解了在Spring 应用中创建Bean的多种方式,包括自动创建,以及手动创建注入方式,实际开发中可以根据业务场景选择合适的方案. 方式1: 使用Spring XML方式配置,该方式用于在纯Spring 应用中,适用于简单的小应用,当应用变得复杂,将会导致Bean管理很麻烦 <bean id="xxxx" class="xxxx.xxxx"/> 方式2: 使用@Component,@Service,@Controler,@Repository注

Spring实例化bean的三种方式

在面向对象编程的过程中,要想调用某个类的成员方法,首先要实例化该类的成员变量. 在Spring 中,实例化Bean有三种方式: 1.构造器实例化:2.静态工厂方式实例化:3.实例化工厂方式实例化 构造器实例化:Spring容器通过Bean对应的类中默认的构造器函数实例化Bean. 1-1.创建一个实体类 Person1 package com.mengma.instance.constructor; public class Person1 { } 1-2.创建Spring配置文件,在 com.

spring创建工厂的三种方式

基础代码 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); People people = applicationContext.getBean("peo", People.class); System.out.println(people); 构造方法(默认无参构造,可以有参构造) 无参构造 <bean i

SSH深度历险(八) 剖析SSH核心原理+Spring依赖注入的三种方式

在java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是"控制反转",通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做. Spring依赖注入(

java创建线程的三种方式及其对比

Java中创建线程主要有三种方式: 一.继承Thread类创建线程类 (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务.因此把run()方法称为执行体. (2)创建Thread子类的实例,即创建了线程对象. (3)调用线程对象的start()方法来启动该线程. package com.thread; public class FirstThreadTest extends Thread{ int i = 0; //重写run方法,run方法的方

创建线程的三种方式

创建线程的三种方式 第一种:通过NSThread的对象方法 第二种:通过NSThread的类方法 第三种:通过NSObject的方法 准备在后台线程调用的方法 longOperation: - (void)longOperation:(id)obj { NSLog(@"%@ - %@", [NSThread currentThread], obj); } 方式1:alloc / init - start - (void)threadDemo1 { NSLog(@"before