Spring第三章：创建对象的三种方式

Spring 创建对象的三种方式

　　1. 通过构造方法创建

　　　　1.1 无参构造创建:默认情况.

　　　　1.2 有参构造创建:需要明确配置

　　　　　　1.2.1 需要在类中提供有参构造方法

package com.bjsxt.pojo;

public class People {
    private int id;
    private String name;

    /**
     *注意这里一旦使用了有参的构造器之后就必须生成这个
     * 无参的构造器不然spring会报错No matching constructor found in class ‘People‘
     */
    public People() {

    }

    public People(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "People [id=" + id + ", name=" + name + "]";
    }
}

　　　　　　1.2.2 在 applicationContext.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="peo" class="com.bjsxt.pojo.People" />

    <!--使用有参构造器注入对象 需要set方法和有参构造器支持-->
    <bean id="peo2" class="com.bjsxt.pojo.People">
        <constructor-arg index="0" value="1"></constructor-arg>
        <constructor-arg index="1" value="zhangsan"></constructor-arg>
    </bean>

</beans>

　　　　　　　　1.2.2.1 如果设定的条件匹配多个构造方法执行最后的构造方法

　　　　　　　　1.2.2.2 index : 参数的索引,从 0 开始

　　　　　　　　1.2.2.3 name: 参数名

　　　　　　　　1.2.2.4 type:类型(区分开关键字和封装类 int 和 Integer)

　　　　1.2.3测试类

package com.bjsxt.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.bjsxt.pojo.People;
import com.bjsxt.pojo.PeopleFactory;

public class Test {
    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        People peo = ac.getBean("peo",People.class);
        System.out.println(peo);

        People peo2 = ac.getBean("peo2",People.class);
        System.out.println(peo2);

    }
}

　　　　1.2.4运行结果

二月 27, 2019 10:59:41 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@179d3b25: startup date [Wed Feb 27 22:59:41 CST 2019]; root of context hierarchy
二月 27, 2019 10:59:41 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
People [id=0, name=null]
People [id=1, name=zhangsan]

　　2. 实例工厂

　　　　2.1 工厂设计模式:帮助创建类对象.一个工厂可以生产多个对象.

　　　　2.2 实例工厂:需要先创建工厂,才能生产对象

　　　　2.3 实现步骤:

　　　　　　2.3.1 必须要有一个实例工厂

package com.bjsxt.pojo;

public class People {
    private int id;
    private String name;

    /**
     *注意这里一旦使用了有参的构造器之后就必须生成这个
     * 无参的构造器不然spring会报错No matching constructor found in class ‘People‘
     */
    public People() {

    }

    public People(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "People [id=" + id + ", name=" + name + "]";
    }
}

package com.bjsxt.pojo;

public class PeopleFactory {

    /**
     * 注意这里千万不能定义为stataic的
     * @return
     */
    public  People newInstance(){
        return new People(1,"测试");
    }
}

　　　　　　2.3.2 在 applicationContext.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">

    <!--&lt;!&ndash; 使用无参构造器注入对象&ndash;&gt;
    <bean id="peo" class="com.bjsxt.pojo.People" />

    &lt;!&ndash;使用有参构造器注入对象 需要set方法和有参构造器支持&ndash;&gt;
    <bean id="peo2" class="com.bjsxt.pojo.People">
        <constructor-arg index="0" value="1"></constructor-arg>
        <constructor-arg index="1" value="zhangsan"></constructor-arg>
    </bean>-->

    <bean id="factory"  class="com.bjsxt.pojo.PeopleFactory"></bean>

    <bean id="peo3" factory-bean="factory" factory-method="newInstance"></bean>

</beans>

　　　　　　2.3.3 测试类

package com.bjsxt.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.bjsxt.pojo.People;
import com.bjsxt.pojo.PeopleFactory;

public class Test {
    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

//        People peo = ac.getBean("peo",People.class);
//        System.out.println(peo);
//
//        People peo2 = ac.getBean("peo2",People.class);
//        System.out.println(peo2);

        People peo = ac.getBean("peo3",People.class);
        System.out.println(peo);

    }
}

　　　　　　2.3.4 测试结果　　

二月 27, 2019 11:12:24 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@179d3b25: startup date [Wed Feb 27 23:12:24 CST 2019]; root of context hierarchy
二月 27, 2019 11:12:24 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
People [id=1, name=测试]

　　3. 静态工厂

　　　　3.1 不需要创建工厂,快速创建对象.

　　　　3.2 实现步骤

　　　　　　3.2.1 编写一个静态工厂(在方法上添加 static)

package com.bjsxt.pojo;

public class PeopleFactory1 {

    /**
     * 注意这里静态工厂需要定义为statis的
     * @return
     */
    public  static People newInstance(){
        return new People(1,"测试");
    }
}

package com.bjsxt.pojo;

public class People {
    private int id;
    private String name;

    /**
     *注意这里一旦使用了有参的构造器之后就必须生成这个
     * 无参的构造器不然spring会报错No matching constructor found in class ‘People‘
     */
    public People() {

    }

    public People(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "People [id=" + id + ", name=" + name + "]";
    }
}

　　　　　　3.2.2 在 applicationContext.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">

    <!--&lt;!&ndash; 使用无参构造器注入对象&ndash;&gt;
    <bean id="peo" class="com.bjsxt.pojo.People" />

    &lt;!&ndash;使用有参构造器注入对象 需要set方法和有参构造器支持&ndash;&gt;
    <bean id="peo2" class="com.bjsxt.pojo.People">
        <constructor-arg index="0" value="1"></constructor-arg>
        <constructor-arg index="1" value="zhangsan"></constructor-arg>
    </bean>-->

    <!--<bean id="factory"  class="com.bjsxt.pojo.PeopleFactory"></bean>-->

    <!--<bean id="peo3" factory-bean="factory" factory-method="newInstance"></bean>-->

    <!--静态工厂注入-->
    <bean id="peo4" class="com.bjsxt.pojo.PeopleFactory1" factory-method="newInstance" />

</beans>

　　　　　　3.2.3 测试类

package com.bjsxt.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.bjsxt.pojo.People;
import com.bjsxt.pojo.PeopleFactory;

public class Test {
    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

//        People peo = ac.getBean("peo",People.class);
//        System.out.println(peo);
//
//        People peo2 = ac.getBean("peo2",People.class);
//        System.out.println(peo2);

//        People peo3 = ac.getBean("peo3",People.class);
//        System.out.println(peo3);

        People peo4 = ac.getBean("peo4",People.class);
        System.out.println(peo4);

    }
}

　　　　　　3.2.4运行结果

二月 27, 2019 11:16:54 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@179d3b25: startup date [Wed Feb 27 23:16:54 CST 2019]; root of context hierarchy
二月 27, 2019 11:16:55 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
People [id=1, name=测试]

原文地址：https://www.cnblogs.com/reload-sun/p/10447755.html

时间： 2024-10-07 09:29:05

Spring第三章：创建对象的三种方式的相关文章

Java反射获取class对象的三种方式，反射创建对象的两种方式

Java反射获取class对象的三种方式,反射创建对象的两种方式 1.获取Class对象在 Java API 中,提供了获取 Class 类对象的三种方法: 第一种,使用 Class.forName 静态方法. 前提:已明确类的全路径名. 第二种,使用 .class 方法. 说明:仅适合在编译前就已经明确要操作的 Class 第三种,使用类对象的 getClass() 方法. 适合有对象示例的情况下 package com.reflection; /** * Created by Liuxd

Java中创建对象的五种方式

我们总是讨论没有对象就去new一个对象,创建对象的方式在我这里变成了根深蒂固的new方式创建,但是其实创建对象的方式还是有很多种的,不单单有new方式创建对象,还有使用反射机制创建对象,使用clone方法去创建对象,通过序列化和反序列化的方式去创建对象.这里就总结一下创建对象的几种方式,来好好学习一下java创建对象的方式. 一.使用new关键字这是我们最常见的也是最简单的创建对象的方式,通过这种方式我们还可以调用任意的够赞函数(无参的和有参的). 比如:Student student = n

js创建对象的四种方式以及消耗时间比较

// Property-less object console.time('zoop1'); var zoop = (function (numObjects) { var pooz = Object.create(null); for(var i = 0; i< numObjects; i++) { pooz[i] = Object.create(null); } return pooz; })(1000000); console.timeEnd('zoop1'); // Using Obje

创建对象的4种方式

/** * <p> * Title: 创建对象的四种方式 * </p> * * * @author lwx * @version 1.0 * @create 2013 1 17 14:03:35 */public class CreateObj implements Cloneable,Serializable{ private static String filename = CreateObj.class.getResource("").getPath()

js中面向对象（创建对象的几种方式）

1.面向对象编程(OOP)的特点: 抽象:抓住核心问题封装:只能通过对象来访问方法继承:从已有的对象下继承出新的对象多态:多对象的不同形态注:本文引用于 http://www.cnblogs.com/yuxingyoucan/p/5797142.html 一.创建对象的几种方式 javascript 创建对象简单的来说,无非就是使用内置对象或各种自定义对象,当然还可以使用JSON,但写法有很多,也能混合使用. 1.工厂方式创建对象:面向对象中的封装函数(内置对象) function cr

第184天：js创建对象的几种方式总结

1.面向对象编程(OOP)的特点: 抽象:抓住核心问题封装:只能通过对象来访问方法继承:从已有的对象下继承出新的对象多态:多对象的不同形态一.创建对象的几种方式 javascript 创建对象简单的来说,无非就是使用内置对象或各种自定义对象,当然还可以使用JSON,但写法有很多,也能混合使用. 1.工厂方式创建对象:面向对象中的封装函数(内置对象) 1 function createPerson(name){ 2 //1.原料 3 var obj=new Object(); 4 //2.

（01）Spring MVC之处理异常的两种方式及优先级

项目开发中异常需要统一处理,总的来说有两种方式,一种是实现HandlerExceptionResolver接口,一种是使用@ExceptionHandler注解的方式.其中Spring已经为我们提供了一个实现了HandlerExceptionResolver接口的类SimpleMappingExceptionResolver,有人把它单独列为一种方式,不过我认为方式越少越好,哈哈哈哈哈,下面记录一下Spring MVC处理异常的这两种方式. 1.实现HandlerExceptionResolve

Java中创建对象的几种方式

Java中创建对象的五种方式: 作为java开发者,我们每天创建很多对象,但是我们通常使用依赖注入的方式管理系统,比如:Spring去创建对象,然而这里有很多创建对象的方法:使用New关键字.使用Class类的newInstance方法.使用Constructor类的newInstance方法.使用Clone方法.使用反序列化. 使用new关键字:这是我们最常见的也是最简单的创建对象的方式,通过这种方式我们还可以调用任意的够赞函数(无参的和有参的).比如:Student student = ne

JavaScript 创建对象的七种方式

转自:xxxgitone.github.io/2017/06/10/JavaScript创建对象的七种方式/ JavaScript创建对象的方式有很多,通过Object构造函数或对象字面量的方式也可以创建单个对象,显然这两种方式会产生大量的重复代码,并不适合量产.接下来介绍七种非常经典的创建对象的方式,他们也各有优缺点. 工厂模式 1 function createPerson(name, job) { 2 var o = new Object() 3 o.name = name 4 o.job

创建对象的第二种方式：克隆clone,要实现Cloneable接口

1 ackage com.wisezone.clone; 2 3 /** 4 * 空接口: 5 * 标识,告诉JVM,通行 6 * 1.克隆 7 * 2.序列化 8 * 9 * 创建对象的第二种方式:克隆clone,要实现Cloneable 10 * @author 王东海 11 * @2017年4月15日 12 */ 13 public class TestClone implements Cloneable 14 { 15 public String name; 16 17 public s