精华内容
下载资源
问答
  • 2016-04-03 20:14:39
    1. 静态工厂方法:工厂初始化之前,工厂中的类已经被实例化放在工厂容器中
    2. 实例工厂方法:工厂在构造方法初始化时,会将类进行实例化放在工厂中
    更多相关内容
  • 主要介绍了Spring工厂方法创建bean实例代码,具有一定借鉴价值,需要的朋友可以参考下
  • 主要给大家介绍了关于Spring中实例化bean的四种方式,分别是setter 方法、构造函数、静态工厂以及实例工厂等四种方法,分别给出了示例代码供大家参考学习,需要的朋友们下面随着小编来一起学习学习吧。
  • 主要介绍了Spring实战之调用实例工厂方法创建Bean操作,结合实例形式分析了实例工厂方法创建Bean相关配置、实现方法及操作注意事项,需要的朋友可以参考下
  • 就Spring IoC容器而言,bean定义基本上描述了创建一个或多个实际bean对象的内容。当需要的时候,容器会从bean定义列表中取得一个指定的...spring实例化bean的三种方式 用构造器来实例化 使用 静态工厂方法实例化 ...

    就Spring IoC容器而言,bean定义基本上描述了创建一个或多个实际bean对象的内容。当需要的时候,容器会从bean定义列表中取得一个指定的bean定义,并根据bean定义里面的配置元数据,使用反射机制来创建一个实际的对象。因此需要告知Spring IoC容器我们将要实例化的对象的类型以及如何实例化对象。

    spring实例化bean的三种方式

    • 用构造器来实例化
    • 使用 静态工厂方法实例化
    • 使用非静态工厂方法实例化

    用构造器来实例化

    造函数实例化是最常见也是最简单的一种实例化bean的方式,该方式也有两种使用方法

    • 无参构造器(默认构造器)
    • 有参构造器

    无参构造器(默认构造器)实例化

    定义一个实体类,提供空的构造方法,并且提供get和set方法,重写toString方法方便看输出

    package spring_di;
    
    public class Users {
    	private String id;
    	private String name;
    	/**
    	 * 空的构造方法
    	 */
    	public Users() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	//======使用空的构造方法必须给属性添加get和set方法============
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "Users [id=" + id + ", name=" + name + "]";
    	}
    }
    

    配置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的方法
    <bean id="user" class="spring_di.Users">
    	<property name="id" value="12345678"></property>  //name对应的是属性名字 value对应的是值
    	<property name="name" value="小莫"></property>
    </bean>
    </beans>
    

    编写测试类:

    package spring_di;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
    	public static void main(String[] args) {
    		ApplicationContext act=new ClassPathXmlApplicationContext(new String[] {"beans.xml"});
    		Users user = (Users) act.getBean("user");
    		System.out.println(user);	
    	}
    }
    
    

    运行结果如下:
    在这里插入图片描述

    有参构造器实例化

    编写实体类,提供有参构造器

    package spring_di;
    
    public class Users {
    	private String id;
    	private String name;
    	/**有参构造器
    	 * @param id
    	 * @param name
    	 */
    	public Users(String id, String name) {
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "Users [id=" + id + ", name=" + name + "]";
    	}
    	
    }
    

    配置xml文件,index=0 对应着实体类中的第一个属性,依次类推。

    <bean id="user" class="spring_di.Users">
    	<constructor-arg index="0" value="4508211998"></constructor-arg>
    	<constructor-arg index="1" value="小明"></constructor-arg>
    </bean>
    

    测试不变,查看控制台输出
    在这里插入图片描述

    使用 静态工厂方法实例化

    编写实体类

    package test;
    
    public class Users {
    	private String id;
    	private String username;
    
    	@Override
    	public String toString() {
    		return "Users [id=" + id + ", username=" + username + "]";
    	}
    
    	public String getId() {
    		return id;
    	}
    
    	public void setId(String id) {
    		this.id = id;
    	}
    
    	public String getUsername() {
    		return username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    }
    
    

    编写工厂类,注意这个工厂的getUserStance()为静态的

    package test;
    
    public class Factory {
    	
    	public static Users getUserStance()   //getUserStance()为静态的
    	{
    		System.out.println("getUserStance()");
    		return new Users();
    	}
    
    }
    
    配置beans.xml文件
    
    ```java
    <bean id="users" class="test.Factory" factory-method="getUserStance"></bean>
    factory-method="getUserStance" 是工厂类里面获取目标实例的方法
    

    编写测试类

    package test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
    
    	public static void main(String[] args) {
    		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
    		
    		Users u=(Users) act.getBean("users");
    		
    		System.out.println(u);
    	}
    
    }
    
    

    查看控制台输出:
    在这里插入图片描述

    使用非静态工厂方法实例化

    修改一下工厂类,将getUserStance()改为非静态的方法

    package test;
    
    public class Factory {
    	
    	public  Users getUserStance()  //非静态的
    	{
    		System.out.println("getUserStance()");
    		return new Users();
    	}
    
    }
    
    

    配置beans.xml,需要配置factory-bean和factory-method方法
    需要先将factory类实例化,再通过factory-method节点调用getUserStance方法获取目标实例。(JavaSE的知识,需要调用一个类里面的非静态方法,那么先要将这个类实例化。载通过该的对象调用该方法)配置beans.xml实际上就是完成这两件事。

    <bean id="factory" class="test.Factory"></bean>
    <bean id="users" factory-bean="factory" factory-method="getUserStance"></bean>
    

    测试类同上

    package test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
    
    	public static void main(String[] args) {
    		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
    		
    		Users u=(Users) act.getBean("users");
    		
    		System.out.println(u);
    	}
    
    }
    
    

    在这里插入图片描述

    展开全文
  • spring bean 实例工厂实例化 在工厂类中创建一个实例方法来实例化对象。在配置bean时需要使用factory-bean属性指定配置的实例工厂,同时还需要使用factory-method属性指定实例工厂中的实例方法 1.创建工厂类...

    spring bean 实例工厂实例化

    在工厂类中创建一个实例方法来实例化对象。在配置bean时需要使用factory-bean属性指定配置的实例工厂,同时还需要使用factory-method属性指定实例工厂中的实例方法

    1.创建工厂类BeanInstanceFactory

    package instance;
    
    public class BeanInstanceFactory {
    	public BeanClass createBeanClassInstance() {
    		return new BeanClass("调用实例工厂方法实例化bean");
    	}
    }
    

    2.编辑配置文件

    <?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="constructorInstance" class="instance.BeanClass">
            <!-- collaborators and configuration for this bean go here -->
        </bean>
        
        <!-- 静态工厂实例化bean  -->
    	<bean id="staticFacoryInstance" class="instance.BeanStaticFactory" factory-method="createInstance">
    	
    	</bean>
    	
    	<!-- 配置工厂 -->
        <bean id="myFactory" class="instance.BeanInstanceFactory">
        </bean>
        <!-- 实例工厂实例化bean  -->
        <bean id="instanceFacoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance">
        </bean>
        
    </beans>

    3.添加测试代码

    package test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import instance.BeanClass;
    
    public class TestInstance {
    	public static void main(String[] args) {
    		ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
    		
    		BeanClass b1 = (BeanClass)appCon.getBean("constructorInstance");
    		System.out.println(b1+b1.message);
    		
    		//测试静态工厂实例化bean
    		BeanClass b2 =(BeanClass)appCon.getBean("staticFacoryInstance");
    		System.out.println(b2+b2.message);
    		
    		//测试实例广场实例化bean
    		BeanClass b3 =(BeanClass)appCon.getBean("instanceFacoryInstance");
    		System.out.println(b3+b3.message);
    	}
    }
    

    展开全文
  • 工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延时到其子类. #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' """ ...
  • (1)使用静态工厂实例化Department (2)使用IOC容器实例化上述类,并对属性使用构造方法注入,然后测试。 (3)模拟三层体系结构,为其创建对应的departmentDao、departmentService、departmentController;实现对...
  • 实例化Bean有三种方式,分别为构造器实例化、静态工厂方式实例化实例工厂方式实例化(其中最常用的是构造器实例化)。 2.2.1 构造器实例化 创建Web项目,导入相关Jar包; 创建名为Bean1的Java类; 创建Spring配置...
  • Bean的实例化1.spring的三种实例化方式2.例子2.1创建一个空的spring工程2.2新建Java类2.3xml文件2.4运行结果3.总结 1.spring的三种实例化方式 1.默认无参的构造器实例化 2.静态工厂方法实例化 3.实例工厂方法实例化 ...

    1.spring的三种实例化方式

    1.默认无参的构造器实例化
    2.静态工厂方法实例化
    3.实例工厂方法实例化
    构造器实例化是指spring容器通过Bean对应类中默认的无参构造方法来实例化。
    静态工厂要求开发者创建一个静态工厂的方法来创建Bean的实例,器Bean配置中的class属性所指定的不在是Bean实例的实现类,而是静态工程类,同时还需要使用factory-method属性来制定所创建的静态工程方法。
    实例工厂不在使用静态方法创建Bean实例,而是采用直接创建Bean实例的方式;在配置文件中,需要实例化的Bean也不是通过class属性直接指向的实例化类,而是通过factory-bean属性指向配置的实例工厂,然后使用factory-method属性确定使用工厂中的哪个方法。

    2.例子

    2.1创建一个空的spring工程

    在这里插入图片描述

    2.2新建Java类

    在这里插入图片描述

    package client;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import domain.def.DefaultBean;
    import domain.inst.InstanceBean;
    import domain.stat.StaticBean;
    
    public class Main {
    
    	@SuppressWarnings("resource")
    	public static void main(String[] args) {
    
    		String defaultPath = "default";
    		String staticPath = "static";
    		String instancePath = "instance";
    		String before = "resource/beans-";
    		String after = ".xml";
    		
    		ApplicationContext applicationContext = null;
    		
    		applicationContext = new ClassPathXmlApplicationContext(before
    				+ defaultPath + after);
    		DefaultBean defaultBean = (DefaultBean) applicationContext
    				.getBean(defaultPath + "Bean");
    		System.out.println(defaultBean);
    		
    		applicationContext = new ClassPathXmlApplicationContext(before
    				+ staticPath + after);
    		StaticBean staticBean = (StaticBean) applicationContext
    				.getBean(staticPath + "Bean");
    		System.out.println(staticBean);
    		
    		applicationContext = new ClassPathXmlApplicationContext(before
    				+ instancePath + after);
    		InstanceBean instanceBean = (InstanceBean) applicationContext
    				.getBean(instancePath + "Bean");
    		System.out.println(instanceBean);
    		
    	}
    
    }
    
    
    package domain.def;
    
    public class DefaultBean {
    
    }
    
    
    package domain.inst;
    
    public class InstanceBean {
    
    }
    
    
    package domain.inst.factory;
    
    import domain.inst.InstanceBean;
    
    public class InstanceBeanFactory {
    
    	public InstanceBean createInstanceBean(){
    		return new InstanceBean();
    	}
    	
    }
    
    
    package domain.stat;
    
    public class StaticBean {
    
    }
    
    
    package domain.stat.factory;
    
    import domain.stat.StaticBean;
    
    public class StaticBeanFactory {
    
    	public static StaticBean createStaticBean(){
    		return new StaticBean();
    	}
    	
    }
    
    

    2.3xml文件

    beans-default.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="defaultBean" class="domain.def.DefaultBean"></bean>
    </beans>
    

    beans-instance.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="instanceBeanFactory" 
    	class="domain.inst.factory.InstanceBeanFactory"></bean>
    	<bean id="instanceBean" factory-bean="instanceBeanFactory"
    	factory-method="createInstanceBean"></bean>
    </beans>
    

    beans-static.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="staticBean" 
    	class="domain.stat.factory.StaticBeanFactory"
    	factory-method="createStaticBean"></bean>
    </beans>
    

    2.4运行结果

    domain.def.DefaultBean@ae45eb6
    domain.stat.StaticBean@4dfa3a9d
    domain.inst.InstanceBean@6500df86
    

    3.总结

    spring的三种实例化方式
    1.默认无参的构造器实例化
    2.静态工厂方法实例化
    3.实例工厂方法实例化

    展开全文
  • c#典型工厂化实现实例,需要的朋友可以参考一下
  • 工厂模式下以通过接口结合列表、泛型和反射等方式实现指定类型的实例化操作
  • 实例工厂实例化 在使用实例工厂实例化Bean时要求开发者在工厂类中创建一个实例方法来创建Bean的实例。在配置Bean时需要使用factory-bean属性指定配置的实例工厂,同时还需要使用factory-method属性 1.创建工厂类...
  • spring bean 静态工厂实例化

    千次阅读 2018-10-14 14:00:14
    spring bean 静态工厂实例化 在工厂类中创建一个静态方法来实例化对象。在配置bean时,class指定静态工厂类,同时还需要使用factory-method属性指定工厂类中的静态方法。 1.创建工厂类BeanStaticFactory ...
  • Spring的三种实例化Bean的方式
  • 使用注解方式实现静态工厂方法实例化Bean 完全使用注解的方式实现静态工厂方法实例化Bean的例子: 1、创建一个学生类 package com.exec.Ioc.T3; public class Student { private String name; private String sex...
  • 在学习Bean实例化前,先让我们来看下IoC容器到底是如何工作。 在此我们以xml配置方式来分析一下: 一、准备配置文件:就像前边Hello World配置文件一样,在配置文件中声明Bean定义也就是为Bean配置元数据。 二、...
  • Spring三种实例化方式

    千次阅读 2018-08-21 23:15:44
    Spring容器支持两种格式的配置文件.properties .xml这...实例化Bean有三种方式,分别为构造器实例化、静态工厂方式实例化实例工厂方式实例化(其中最常用的是构造器实例化) 1.构造器实例化 public class Insta...
  • Bean实例化的三种方式

    千次阅读 2019-09-21 23:53:02
    实例化的三种方式 1.使用无参构造方法实例化(最常用) xml配置 <bean id="userDao" class="dao.impl.UserDaoImpl"/> id为要实例化的对象它是Bean实例在Spring容器中的唯一标识 class 是要实例化的类的全类名 ...
  • 该篇博客关于工厂方法与FactoryBean,其实就是在Spring中不再使用Spring创建Bean实例,而是利用工厂方法与FactoryBean把Bean创建过程转移到开发者手中 ...4、FactoryBean实例化Bean(工厂Bea...
  • 还有一种实例化Bean的方式是采用是实例工厂,此种方式的工厂类中不再使用静态方法创建Bean实例,而是采用直接创建Bean实例的方式,同时在配置文件中,需要实例化的Bean也并不是通过ckass属性直接指向的实例化类,...
  • 使用静态工厂是实例化Bean的另一种实例化方式。该方式要求开发者创建一个静态发工厂的方法来创建Bean的实例,其Bean配置中的class属性所指定的不再是Bean实例的实现类,而是静态工厂类,同时还需要使用factory-...
  • 三种实例化bean的方式

    千次阅读 2018-08-16 09:42:36
    三种实例化bean的方式: 在Spring中有三种实例化bean的方式: 1、使用类构造器实例化;(默认无参数,一般使用这种方式) 2、使用静态工厂方法实例化(简单工厂模式); 3、使用实例化工厂实例化工厂方法模式...
  • 2.使用工厂方法(静态工厂方法、实例工厂方法) 3.实现FactoryBean接口 二.使用类构造器实例化: 在配置bean时,使用class属性指定类的全名称(即全类名) 三.工厂方法实例化 1.静态工厂方法: 方法就是将对象创建过程...
  • 静态工厂实例化 在使用静态工厂实例化Bean时要求开发者在工厂类中创建一个静态方法来创建Bean的实例。在配置Bean时,class属性指定静态工厂类,同时还需要使用factory-method属性指定工厂类中的静态方法 **1.创建...
  • 调用工厂模式来实现对象实例化

    千次阅读 2019-05-19 09:46:53
    就是Class A 想调用Class B,那么只是调用B的方法,而至于B的实例化,就交给工厂类。 工厂模式可以降低代码重复。如果创建B过程都很复杂,需要一定的代码量,而且很多地方都要用到,那么就会有很多的重复代码。可以...
  • 创建(实例化)对象的五种方式

    万次阅读 2018-08-28 10:16:52
    Java中创建(实例化)对象的五种方式 用new语句创建对象,这是最常见的创建对象的方法。 通过工厂方法返回对象,如:String str = String.valueOf(23); 运用反射手段,调用java.lang.Class或者java.lang....
  • Spring 使用静态工厂方式实例化Bean

    千次阅读 2014-12-20 21:00:47
    知识点介绍:静态工厂顾名思义,就是通过调用静态工厂的方法来获取自己需要的对象,为了让spring管理所有对象,我们不能直接通过"工程类.静态方法()"来获取对象,而是依然通过spring注入的形式获取。 【转载使用,请...
  • 几种对象实例化方式详解

    千次阅读 2019-11-22 23:04:50
    一)对象实例化常用方式 方式一:直接new一个对象,最常用的一种。 方式二:反射,通过Class.forName("类的全限定名")。...备注:工厂模式实例化、克隆实例化两种比较少用。 二)new一个对象 声明一个对...
  • 目录第一种:使用构造器实例化Bean第二种:使用静态工厂方式实例化Bean第三种:使用实例工厂方法实例化Bean第四种:用 setter 方式 Spring IoC容器如何实例化Bean呢?传统应用程序可以通过new和反射方式进行实例化...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 256,986
精华内容 102,794
关键字:

实例工厂方式实例化