Study(1) Spring创建对象三种方式

spring Spring对象创建三种方式

创建时间:2020-04-22 16:56

阅读:

1.spring简介
2.启动spring容器
1. (1).导包
2. (2).配置文件

3.spring创建对象（三种方式）

(1).新建Student类
(2).applicationContext.xml
(3).测试

4.Spring创建对象常用设置

(1).作用域（applicationContext.xml）
(2).生命周期
(3).延迟加载

1.spring简介

(1).spring是开源的用来简化应用开发的框架。

(2).spring对常用的api做了封装和简化（spring jdbc 访问数据库时，不用考虑获取连接和关闭连接）

(3).spring提供了一个容器，帮我们创建对象以及建立对象之间的依赖关系，可以降低对象的耦合度，方便代码维护

(4).spring可以将其他的一些框架集成进来（调用quartz调度框架）

2.启动spring容器

(1).导包

<!-- 1.spring核心依赖 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <!-- 2.spring dao依赖 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <!-- 3.spring web依赖 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <!-- 4.Spring test依赖：方便做单元测试和集成测试  -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring.version}</version>
  </dependency>

(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"
    xmlns:beans="http://www.springframework.org/schema/beans" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:lang="http://www.springframework.org/schema/lang"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:util="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/lang http://www.springframework.org/schema/tx/spring-lang-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/tx/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/tx/spring-util-3.2.xsd">

</beans>

(3).启动spring容器（main方式测试用）

public class FirstSpring {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println(applicationContext);
    }
}

3.spring创建对象（三种方式）

方法一： 使用无参构造器创建对象，
            id属性：bean的名称，要求唯一，
            class属性：类的全限定名（要求包含包名） 
        <bean id="student1" class="cn.com.sinodata.Student"></bean>
        <bean id="date1" class="java.util.Date"></bean>

方法二：使用静态工厂方法创建对象：通过调用类的静态方法来创建对象
            factory-method属性：指定一个静态方法，spring容器会调用这个静态方法来创建对象 
        <bean id="calendar" class="java.util.Calendar" factory-method="getInstance"></bean>

 方法三：使用实例工厂方法创建对象:通过调用对象的实例方法来创建对象
            factory-bean属性: 指定一个bean的id
            factory-method属性: 指定一个方法
        <bean id="time1" factory-bean="calendar" factory-method="getTime"></bean>

(1).新建Student类

public class Student {
    public Student(){
        System.out.println("构造器  Student()");
    }
}

(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"
    xmlns:beans="http://www.springframework.org/schema/beans" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:lang="http://www.springframework.org/schema/lang"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:util="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/lang http://www.springframework.org/schema/tx/spring-lang-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/tx/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/tx/spring-util-3.2.xsd">


    <!--方法一： 使用无参构造器创建对象，
                id属性：bean的名称，要求唯一，
                class属性：类的全限定名（要求包含包名） -->
    <bean id="student1" class="cn.com.sinodata.Student"></bean>
    <bean id="date1" class="java.util.Date"></bean>

    <!-- 方法二：使用静态工厂方法创建对象：通过调用类的静态方法来创建对象
                factory-method属性：指定一个静态方法，spring容器会调用这个静态方法来创建对象 -->
    <bean id="calendar" class="java.util.Calendar" factory-method="getInstance"></bean>

    <!-- 方法三：使用实例工厂方法创建对象:通过调用对象的实例方法来创建对象
                factory-bean属性: 指定一个bean的id
                factory-method属性: 指定一个方法
                -->
    <bean id="time1" factory-bean="calendar" factory-method="getTime"></bean>

</beans>

(3).测试

public class FirstSpring {
    public static void main(String[] args) {    
    //启动容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

方法一： 
        //获取对象
        Student student = applicationContext.getBean("student1",Student.class);
        System.out.println(student);

        Date date1 = applicationContext.getBean("date1", Date.class);
         System.out.println(date1);

方法二：
        Calendar calendar = applicationContext.getBean("calendar", Calendar.class);
        System.out.println(calendar);

方法三：
        Date date = applicationContext.getBean("time1",Date.class);
        System.out.println(date);

    }
}

4.Spring创建对象常用设置

(1).作用域（applicationContext.xml）

<!--scope属性：用来配置作用域，缺省值
             singleton: 只会创建一个实例
             prototype: 每调一次getBean就会创建一个实例
             -->

       默认情况下，scope属性表现为scope="singleton"，容器只会创建一个实例
      <bean id="scopeTest" class="cn.com.sinodata.ScopeTest"></bean>

      每调一次getBean，容器就会创建一个实例，即多个实例
      <bean id="scopeTest" class="cn.com.sinodata.ScopeTest" scope="prototype"></bean>

(2).生命周期

init-method: 指定对象初始化方法名（spring容器创建对象后，会立即调用初始化方法）
       destroy-method：指定销毁方法名（spring容器关闭之前，会先调用对象的销毁方法销毁对象），
                        只有作用域为单例时，销毁方法才会执行
-->
<bean id="message" class="cn.com.sinodata.MessageBean" init-method="init" destroy-method="destroy"></bean>

第一步：新建MessageBean类：
    public class MessageBean {
        public MessageBean(){
            System.out.println("messagebean 无参构造方法");
        }
        public void init(){
            System.out.println("init()");
        }
        public void sendMessage(){
            System.out.println("用来发送消息");
        }
        public void destroy(){
            System.out.println("destroy()");
        }
    }

第二步：applicationContext.xml配置
    <!--
           init-method: 指定对象初始化方法名（spring容器创建对象后，会立即调用初始化方法）
           destroy-method：指定销毁方法名（spring容器关闭之前，会先调用对象的销毁方法销毁对象），只有作用域为单例时，销毁方法才会执行
    -->
    <bean id="message" class="cn.com.sinodata.MessageBean" init-method="init" destroy-method="destroy"></bean>

第三步：测试

    AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    MessageBean messageBean = applicationContext.getBean("message", MessageBean.class);
    messageBean.sendMessage();

    applicationContext.close();//AbstractApplicationContext此类存在 close方法

(3).延迟加载

spring容器启动后，会将所有作用域为单例的bean创建好，

当lazy-init=true时，启动容器时不会被实例化，调用getBean时才会实例化。

lazy-init:指定是否延迟加载，若true，表示延迟加载

现象如下：

第一步：
    public class ScopeBean {
        public ScopeBean(){
            System.out.println("scope 构造器");
        }
    }

    public class MessageBean {
        public MessageBean(){
            System.out.println("messagebean 无参构造方法");
        }
        public void init(){
            System.out.println("init()");
        }
        public void sendMessage(){
            System.out.println("用来发送消息");
        }
        public void destroy(){
            System.out.println("destroy()");
        }
    }

第二步：applicaitonContext.xml

    方式一：默认情况下，lazy-init = false
              <!--scope属性：用来配置作用域，缺省值
                           singleton:创建一个实例
                           prototype: 每调一次getBean就会创建一个实例
                           -->
            <bean id="scopeBean" class="cn.com.sinodata.ScopeBean" scope="prototype"></bean>

            <!--
                若不指定scope属性时，默认为单例
                   init-method: 指定对象初始化方法名（spring容器创建对象后，会立即调用初始化方法）
                   destroy-method：指定销毁方法名（spring容器关闭之前，会先调用对象的销毁方法销毁对象）
            -->
            <bean id="message" class="cn.com.sinodata.MessageBean" init-method="init" destroy-method="destroy"></bean>


    方式二：lazy-init:指定是否延迟加载，若true，表示延迟加载
            <!--
                   init-method: 指定对象初始化方法名（spring容器创建对象后，会立即调用初始化方法）
                   destroy-method：指定销毁方法名（spring容器关闭之前，会先调用对象的销毁方法销毁对象），只有作用域为单例时，销毁方法才会执行

                   lazy-init:指定是否延迟加载，若true，表示延迟加载
            -->
            <bean id="message" class="cn.com.sinodata.MessageBean" init-method="init" destroy-method="destroy" lazy-init="true"></bean>

第三步：启动spring容器
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

第四步：测试
    applicaitonContext.xml方式一：
                控制台输出：
                        messagebean 无参构造方法
                        init()
    applicaitonContext.xml方式二：
                控制台无输出