精华内容
下载资源
问答
  • 2017-10-03 19:07:58

    什么是静态工厂?

    工厂类所有方法都是静态的

    /**
     * 里面一般来说都是静态的方法
     * @author memory_coder
     * @2017年10月2日 上午10:05:31
     */
    public class StaticBeanFactory {
    	public static User getUser()
    	{
    		return new UserImpl();
    	}
    }
    在Application.xml文件中的配置

    
    <!-- class为静态工厂类的全限定类名 factory-method为使用的静态方法
    <bean id="user" class="com.slxy.factory.StaticFactory" factory-method="getUser" ></bean>

    什么是实例工厂?

    工厂类的方法为静态方法

    /**
     * @author memory_coder
     * @2017年10月3日 下午6:49:44
     */
    public class InstantBeanFactory {
    	public User getUser()
    	{
    		return new UserImpl();
    	}
    }

    在Application.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="userFactory" class="com.slxy.factory.InstantBeanFactory" ></bean>
    		<!-- 配置工厂实例的对象 factory-bean为使用实例工厂的id属性值   factory-method为调用工厂的方法-->
    	<bean id="userId" factory-bean="userFactory" factory-method="createUserService"></bean>
    </beans>
    使用方法都一样

    /**
     * @author memory_coder
     * @2017年10月3日 下午6:57:28
     */
    public class InstantBeanFactoryText {
    	@Test
    	public void createUserService()
    	{
    		// 加载spring配置文件
    		ApplicationContext context = new ClassPathXmlApplicationContext("InstantApplication.xml");
    		// 获得user实例对象
    		UserS us = context.getBean("userId",User.class);
    		us.addUser();
    	}
    }
    


    更多相关内容
  • spring静态工厂和实例工厂的区别

    千次阅读 2018-11-06 16:46:15
    --实例工厂方法是先将工厂实例化--> main测试方法(使用单元测试的方法进行测试) package com.tang; import org.junit.Before; import org.junit.Test; import org.springframework....

    新闻实体类NewsBean

    package com.tang;
    
    /**
     * 新闻实体类
     */
    public class News {
        String title;
        String content;
    
        @Override
        public String toString() {
            return "News{" +
                    "title='" + title + '\'' +
                    ", content='" + content + '\'' +
                    '}';
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
        public String getContent() {
            return content;
        }
    
        public void setContent(String content) {
            this.content = content;
        }
    
        public News(String title, String content) {
    
            this.title = title;
            this.content = content;
        }
    
        public News() {
    
        }
    }
    

    实例工厂方法

    package com.tang;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 实例工厂
     */
    public class InstanceFactory {
        Map<String,News> newsMap = new HashMap<String,News>();
    
        public InstanceFactory(){
            newsMap.put("news1",new News("InstanceFactory标题1","内容1"));
            newsMap.put("news2",new News("InstanceFactory标题2","内容2"));
        }
    
        public News getNews(String name){
            return newsMap.get(name);
        }
    }
    

    静态工厂方法

    package com.tang;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 静态工厂
     */
    public class StaticFactory {
        private static Map<String,News> newsMap = new HashMap<String,News>();
        static {
            newsMap.put("news1",new News("StaticFactory标题1","内容1"));
            newsMap.put("news2",new News("StaticFactory标题2","内容2"));
        }
    
        public static News getNews(String name){
            return newsMap.get(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 id="news11" class="com.tang.StaticFactory" factory-method="getNews">
            <constructor-arg value="news1"/>
        </bean>
        <bean id="news12" class="com.tang.StaticFactory" factory-method="getNews">
            <constructor-arg value="news2"/>
        </bean>
    
        <!--实例工厂方法是先将工厂实例化-->
        <bean id="instanceFactory" class="com.tang.InstanceFactory"/>
    
        <bean id="news21" factory-bean="instanceFactory" factory-method="getNews">
        <constructor-arg value="news1"/>
        </bean>
        <bean id="news22" factory-bean="instanceFactory" factory-method="getNews">
            <constructor-arg value="news2"/>
        </bean>
    </beans>

    main测试方法(使用单元测试的方法进行测试)

    package com.tang;
    
    import org.junit.Before;
    import org.junit.Test;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class test {
        private ClassPathXmlApplicationContext ctx;
    
        @Before
        public void before() {
            //初始化Spring容器,当Spring容器初始化时,会自动加载配置文件,然后根据配置文件中的内容初始化Bean
            ctx = new ClassPathXmlApplicationContext("application.xml");
        }
    
        @Test
        public void test1() {
            News news11 = (News) ctx.getBean("news11");
            System.out.println(news11);
            News news12 = (News) ctx.getBean("news12");
            System.out.println(news12);
        }
    
        @Test
        public void test2() {
            News news21 = (News) ctx.getBean("news21");
            System.out.println(news21);
            News news22 = (News) ctx.getBean("news22");
            System.out.println(news22);
        }
    }
    

    测试结果

    test1:

    News{title='StaticFactory标题1', content='内容1'}
    News{title='StaticFactory标题2', content='内容2'}
    
    Process finished with exit code 0

    test2:

    News{title='InstanceFactory标题1', content='内容1'}
    News{title='InstanceFactory标题2', content='内容2'}
    
    Process finished with exit code 0

    参考https://blog.csdn.net/woshiwusonghaha/article/details/72801187

    展开全文
  • 主要介绍了Spring实例工厂方法和静态工厂方法实例代码,具有一定借鉴价值,需要的朋友可以参考下
  • Spring创建静态工厂和实力化工厂对象

    文章中使用的实体类等信息为上一章内容,详情查看

    1:使用静态工厂创建对象

    1.1: java静态工厂类

    public class Factory {
        public static User getUser(String name, int age, char sex){
            return new User(age,sex,new Date(),name);
        }
    }
    

    1.2:配置文件创建对象

    <!--    使用静态工厂模式创建对象     静态工厂类                       调用工厂的那个方法创建对象-->
        <bean id="userFact" class="com.wangYuan.test.Factory.Factory" factory-method="getUser">
        <!-- 调用静态工厂方法时候,传递参数-->
            <constructor-arg name="name" value="张三"></constructor-arg>
            <constructor-arg name="age" value="21"></constructor-arg>
            <constructor-arg name="sex" value=""></constructor-arg>
        </bean>
    

    1.3: 代码测试

        /**
         * 测试调用静态工厂方式获取对象
         */
        @Test
        public void test03(){
            ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("spring01.xml");
            User user02 = (User)app.getBean("userFact");
            System.out.println(user02);
        }
    

    2: 实例化工程创建对象

    1.1: java实例化工厂类

    public class Factory {
        public  User getUser01(String name,int age,char sex){
            return new User(age,sex,new Date(),name);
        }
    }
    
    

    1.2:配置文件创建对象

    <!--    实例化工厂模式创建对象
            先创建工厂对象,在调用工厂方法创建对象
    -->
        <bean id="userFactory" name="Factory" class="com.wangYuan.test.Factory.Factory"></bean>
        <bean id="userFact01"  factory-bean="userFactory" factory-method="getUser01">
            <constructor-arg name="name" value="张三"></constructor-arg>
            <constructor-arg name="age" value="21"></constructor-arg>
            <constructor-arg name="sex" value=""></constructor-arg>
        </bean>
    

    1.3: 代码测试

        /**
         * 测试调用实例化工厂方式获取对象
         */
        @Test
        public void test04(){
            ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("spring01.xml");
            User user02 = (User)app.getBean("userFact01");
            System.out.println(user02);
    
        }
    
    展开全文
  • 静态工厂实例工厂 创建AirPlane基础类 package com.atguigu.bean; public class AirPlane { private String fdj; //飞机品牌 private String yc; //飞机翼长 private Integer personNum; //可载人数 ...

    静态工厂与实例工厂

    1. 创建AirPlane基础类

      package com.atguigu.bean;
      
      public class AirPlane {
      
      	private String fdj;	//飞机品牌
      	private String yc;	//飞机翼长
      	private Integer personNum;	//可载人数
      	private String jzName;	//机长名字
      	private String fjsName;	//副机长名字
      
      	@Override
      	public String toString() {
      		return "AirPlane [fdj=" + fdj + ", yc=" + yc + ", personNum=" + personNum + ", jzName=" + jzName + ", fjsName="
      				+ fjsName + "]";
      	}
      
      	public String getFdj() {
      		return fdj;
      	}
      
      	public void setFdj(String fdj) {
      		this.fdj = fdj;
      	}
      
      	public String getYc() {
      		return yc;
      	}
      
      	public void setYc(String yc) {
      		this.yc = yc;
      	}
      
      	public Integer getPersonNum() {
      		return personNum;
      	}
      
      	public void setPersonNum(Integer personNum) {
      		this.personNum = personNum;
      	}
      
      	public String getJzName() {
      		return jzName;
      	}
      
      	public void setJzName(String jzName) {
      		this.jzName = jzName;
      	}
      
      	public String getFjsName() {
      		return fjsName;
      	}
      
      	public void setFjsName(String fjsName) {
      		this.fjsName = fjsName;
      	}
      
      }
      
      
    2. 创建静态工厂类

      package com.atguigu.factory;
      
      import com.atguigu.bean.AirPlane;
      
      /**
       * 静态工厂
       * @author Keeper
       *
       */
      public class AirPlaneStaticFactory {
      	
      	public static AirPlane getAirPlane(String jzName){
      		System.out.println("AirPlaneStaticFactory正在造飞机!");
      		AirPlane airPlane = new AirPlane();
      		airPlane.setFdj("蓝天");
      		airPlane.setFjsName("lfy");
      		airPlane.setJzName(jzName);
      		airPlane.setPersonNum(30);
      		airPlane.setYc("198.8cm");
      		return airPlane;
      	}
      	
      }
      
      
    3. 创建实例工厂类

      package com.atguigu.factory;
      
      import com.atguigu.bean.AirPlane;
      
      /**
       * 实例工厂
       * @author Keeper
       *
       */
      public class AirPlaneInstanceFactory {
      
      	public AirPlane getAirPlane(String jzName){
      		System.out.println("AirPlaneInstanceFactory正在造飞机!");
      		AirPlane airPlane = new AirPlane();
      		airPlane.setFdj("蓝天");
      		airPlane.setFjsName("lfy");
      		airPlane.setJzName(jzName);
      		airPlane.setPersonNum(30);
      		airPlane.setYc("198.8cm");
      		return airPlane;
      	}
      	
      }
      
      
    4. 工厂配置文件

    <?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">
    
    	<!-- 
    		工厂模式:工厂帮我们创建对象,有一个专门创建对象的类
    		AirPlane ap = AirPlaneFactory.getAirPlane(String jzName);
    		
    		静态工厂:工厂本身不用创建,通过静态方法调用
    		实例工厂:工厂本身需要创建,需要先new工厂类对象
    	 -->
    	 
    	 <!-- 静态工程(不需要创建工厂本身) -->
    	 <!-- factory-method:指定哪个方法是工厂方法 -->
    	 <bean id="airPlane01" class="com.atguigu.factory.AirPlaneStaticFactory" 
    	 factory-method="getAirPlane">
    	 	<!-- 可以为方法指定参数 -->
    	 	<constructor-arg value="张三"></constructor-arg>
    	 </bean>
    	 
    	 <!--
    	 	实例工厂
    	 		1、配置出实例工厂类对象
    	 		2、配置要创建的airPlane使用哪个工厂创建
    	 			(1)指定工厂实例(factory-bean)
    	 			(2)指定工厂方法(factory-method)
    	 		3、传参数
    	  -->
    	 <bean id="airPlane02" class="com.atguigu.factory.AirPlaneInstanceFactory"></bean>
    	 <!--
    	 	 factory-bean:指定当前对象创建使用哪个工厂 
    	 	 factory-method:指定哪个方法是工厂方法
    	 -->
    	 <bean id="airPlane" class="com.atguigu.bean.AirPlane" 
    	 factory-bean="airPlane02"  factory-method="getAirPlane">
    	 	<constructor-arg value="李四"></constructor-arg>
    	 </bean>
    	 
    </beans>
    
    
    1. 测试

      package com.atguigu.test;
      
      import org.junit.Test;
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      
      import com.atguigu.factory.AirPlaneStaticFactory;
      
      import sun.awt.AppContext;
      
      public class AirPlaneTest {
      
      	private ApplicationContext context = new ClassPathXmlApplicationContext("bean_air.xml");
      
      	/**
      	 * 测试静态工厂
      	 */
      	@Test
      	public void testAirPlaneStaticFactory() {
      
      		Object airPlane = context.getBean("airPlane01");
      		System.out.println(airPlane);
      		/*
      		 * 	AirPlaneStaticFactory正在造飞机!
      			AirPlane [fdj=蓝天, yc=198.8cm, personNum=30, jzName=张三, fjsName=lfy]
      		 */
      
      	}
      
      	/**
      	 * 测试实例工厂
      	 */
      	@Test
      	public void testAirPlaneInstanceFactory() {
      		Object airPlane = context.getBean("airPlane");
      		System.out.println(airPlane);
      	}
      	/*
      	 *	AirPlaneStaticFactory正在造飞机!
      		AirPlaneInstanceFactory正在造飞机!
      		AirPlane [fdj=蓝天, yc=198.8cm, personNum=30, jzName=李四, fjsName=lfy] 
      	 */
      
      }
      
      
    展开全文
  • 这三种方式分别为:使用静态工厂...静态工厂和实例工厂区别:静态工厂指的是工厂的服务是静态的,也就是工厂提供的方法是static的,那么这些方法仅有工厂提供以及管理更新等,跟客户端或者说调用端是没有关系的;...
  • Spring静态工厂与动态工厂的创建与配置 静态工厂创建对象: 一:通过静态工厂模式创建对象 package cn.jz.beans; public class Bean1 { public void add(){ System.out.println("bean1 ........"); } } ...
  • 1.静态/实例工厂 静态工厂: 就是生成实例对象,所有的方法必须是static 实例工厂: 就是先创建类对象,通过对象来调用创建实例对象的方法 静态工厂创建的方法必须是静态方法 2.代码执行: 1.静态 package ...
  • 静态工厂创建对象是一步到位,写一个bean标签即可 <!-- 使用静态工厂创建对象 --> <!-- 一步到位:创建飞机对象,只需要把class指定为工厂类,然后添加造飞机的方法即可 --> <bean id="plane01" ...
  • 一、静态工厂方法注入bean   调用静态工厂方法创建 bean 是将对象创建的过程封装到静态方法中 , 当客户端需要对象时 , 只需要简单地调用静态方法 , 而不需要关心创建对象的细节。 在XML文件中配置bean时,要...
  • 静态工厂方法:直接调用静态方法可以返回Bean的实例 package com.zw.factory;import java.util.HashMap;import java.util.Map;public class StaticCarFactory {/*** 静态工厂方法:直接调用静态方法可以返回Bean的...
  • JavaEE spring静态工厂创建实例
  • 静态工厂方法和实例工厂方法区别

    千次阅读 2019-12-26 17:55:13
    在学习Spring bean的实例化方式的时候遇到的一个问题,Spring bean实例化有3种方法 1、构造器生成 2、静态工厂方法 3、实例工厂方法 那么问题来了,什么是静态工厂方法,什么是实例工厂方法? 1、静态工厂方法 就是...
  •  (1)实例工厂 实例方法                          (2)静态工厂             对于一二 scope配置单例 则容器初始化调用工厂方法返回一次 若为原型 则每次调用工厂方法返回工厂产生对象 两者...
  • 在学习Spring bean的实例化方式的时候遇到的一个问题,Spring bean实例化有3种方法 1、构造器生成 2、静态工厂方法 3、实例工厂方法 那么问题来了,什么是静态工厂方法,什么是实例工厂方法? 静态工厂方法 ...
  • spring bean 静态工厂实例

    千次阅读 2018-10-14 14:00:14
    spring bean 静态工厂实例化 在工厂类中创建一个静态方法来实例化对象。在配置bean时,class指定静态工厂类,同时还需要使用factory-method属性指定工厂类中的静态方法。 1.创建工厂类BeanStaticFactory ...
  • 使用静态工厂实例化Bean的另外一种方式(还有一种是构造器实例化),该方式要求开发者创建一个静态工厂的方法来创建Bean,其Bean配置中所指的不在是Bean的实体类而是静态工厂类,并且还需要factory-method属性来指定...
  • 一、静态工厂方法注入bean 利用静态工厂方法可以把bean注入到IOC容器中。在XML文件中配置bean时,要指定class的属性为工厂的类;factory-method属性指定工厂类中工厂方法,用于创建bean;constrctor-arg用于给工厂...
  • 通过调用静态工厂方法创建Bean调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中。当客户端需要对象时,只需要简单地调用静态方法,而不关心创建对象的细节。要声明通过静态方法创建的Bean,需要在Bean的...
  • Spring 使用静态工厂方式实例化Bean

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

    千次阅读 2017-05-29 11:10:22
    静态工厂和实例工厂方法配置: <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=...
  • 主要介绍了Spring实战之使用静态工厂方法创建Bean操作,结合实例形式分析了静态工厂方法创建Bean的相关实现步骤与操作注意事项,需要的朋友可以参考下
  • Spring实例工厂方法和静态工厂方法 静态工厂方法:直接调用静态方法可以返回Bean的实例 package com.zhu.string.factory; import java.util.HashMap; import java.util.Map; public class StaticCarFactory { /*...
  • 2. 使用静态工厂方法实例化 factory‐method属性标签 <bean class="com.tuling.service.impl.UserServiceImpl" id="userService2" factory‐method="createUserServiceInstance" > </bean> public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,329
精华内容 18,131
关键字:

spring静态工厂和实例工厂

spring 订阅