03 Spring对Bean的管理

Spring创建bean的三种方式

1.第一种方式：使用默认构造函数创建

bean.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="accountService" class="com.itzn.service.AccountServiceImpl"></bean>
</beans>

AccountServiceImpl.java

package com.itzn.service;
import com.itzn.dao.AccountDaoImpl;
import com.itzn.dao.IAccountDao;
public class AccountServiceImpl implements IAccountService {
    public  AccountServiceImpl(){
        System.out.println("默认构造");
    }
    public void save() {
        System.out.println("保存方法");
    }
}

测试：AccountTest.java

package com.itzn.ui;

import com.itzn.dao.AccountDaoImpl;
import com.itzn.dao.IAccountDao;
import com.itzn.service.AccountServiceImpl;
import com.itzn.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AccountTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService iAccountService = (IAccountService) ac.getBean("accountService");
        System.out.println(iAccountService);

        iAccountService.save();
    }
}

输出结果：

2.第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）

bean.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="accountService" class="com.itzn.service.AccountServiceImpl"></bean>
    -->
    <!-- 第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器） -->
    <bean id="beanFactory" class="com.itzn.factory.BeanFactory"></bean>
    <bean id="accountService" factory-bean="beanFactory" factory-method="getASIBean"></bean>
</beans>

BeanFactory.java

package com.itzn.factory;

import com.itzn.service.AccountServiceImpl;
public class BeanFactory {
    public AccountServiceImpl getASIBean(){
        System.out.println("BeanFactory实例工厂的getASIBean方法...");
        return new AccountServiceImpl();
    }
}

AccountTest .java

package com.itzn.ui;

import com.itzn.dao.AccountDaoImpl;
import com.itzn.dao.IAccountDao;
import com.itzn.service.AccountServiceImpl;
import com.itzn.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService iAccountService = (IAccountService) ac.getBean("accountService");
        System.out.println(iAccountService);

        iAccountService.save();
    }
}

测试结果：

3.第三种方式：第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器）

bean.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="accountService" class="com.itzn.service.AccountServiceImpl"></bean>
    -->
    <!-- 第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
    <bean id="beanFactory" class="com.itzn.factory.BeanFactory"></bean>
    <bean id="accountService" factory-bean="beanFactory" factory-method="getASIBean"></bean>
    -->
    <!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器） -->
   <bean id="accountService" class="com.itzn.factory.StaticFactory" factory-method="getASIBean"></bean>
</beans>

StaticFactory.java

package com.itzn.factory;
import com.itzn.service.AccountServiceImpl;
public class StaticFactory {

    public static AccountServiceImpl getASIBean(){
        System.out.println("StaticFactory实例工厂的getASIBean方法...");
        return new AccountServiceImpl();
    }
}

AccountTest.java

package com.itzn.ui;
import com.itzn.dao.AccountDaoImpl;
import com.itzn.dao.IAccountDao;
import com.itzn.service.AccountServiceImpl;
import com.itzn.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AccountTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService iAccountService = (IAccountService) ac.getBean("accountService");
        System.out.println(iAccountService);

        iAccountService.save();
    }
}

测试结果：

bean对象的作用范围
scope属性 :
* singleton:单例的.(默认的值.)
* prototype:多例的.
* request:web开发中.创建了一个对象,将这个对象存入request范围,request.setAttribute();
* session:web开发中.创建了一个对象,将这个对象存入session范围,session.setAttribute();
* globalSession:一般用于Porlet应用环境.指的是分布式开发.不是porlet环境,globalSession等同于session;
实际开发中主要使用singleton,prototype

Customer.java

package cn.itzn.srping.demo3;
public class Customer {
    public Customer(){
        System.out.println("Customer被实例化了");
    }
}

bean.xml

//单例配置
 <bean id="customer" class="cn.itzn.srping.demo3.Customer"></bean>
//多例配置
 <bean id="customer" class="cn.itzn.srping.demo3.Customer" scope="prototype"></bean>

SpringTest.java

public class SpringTest {
     @Test
    public void Dome1()
    {
         ApplicationContext myContext=new ClassPathXmlApplicationContext("bean.xml");
         Customer customer1=(Customer) myContext.getBean("customer");
          System.out.println(customer1);

         Customer customer2=(Customer) myContext.getBean("customer");
         System.out.println(customer2);
    }
}

bean对象的生命周期
单例对象：scope="singleton"
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope="prototype"
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

原文地址：https://www.cnblogs.com/itmu89/p/12078191.html

时间： 2024-10-31 19:49:24

03 Spring对Bean的管理的相关文章

spring对bean的管理细节

spring对bean的管理细节 1. 创建bean的三种方式 1.1 方式一 使用默认构造函数创建 在Spring的配置文件中使用bean标签, 配以id和class属性之后, 且没有其他属性和标签时 采用的就是默认构造函数创建bean对象, 此时类中如果没有默认构造函数, 则对象无法创建 <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"><

03 Spring框架 bean的属性以及bean前处理和bean后处理

上一节我们给出了三个小demo,具体的流程是这样的: 1.首先在aplicationContext.xml中添加<bean id="自定义id" class="包名.类名">.(还有两种工厂配置) 2.其次写一个自定义类,里面只包含一个系统输出的show(). 3.使用 ApplicationContext hw=new classpathXmlApplicationContext("applicationContext.xml");

IOC——Spring的bean的管理（注解方式）

注解(简单解释) 1.代码里面特殊标记,使用注解可以完成一定的功能 2.注解写法 @注解名称(属性名称=属性值) 3.注解使用在类上面,方法上面和属性上面 注意:注解方式不能完全替代配置文件方式 Spring注解开发准备工作 1.引入Jar包(Maven项目) pom文件 <dependencies> <!-- 引入一个spring-context 会自动依赖 spring-core.spring-beans.spring-expression 三个核心包 以及spring-aop.ao

spring的配置介绍和bean的管理方式

前言 不管说什么框架,我们总是难以逃脱该框架的配置文件,所以接下来我们就要讲述一下spring的配置文件的相关标签的配置,另外会介绍一下spring的bean的管理方式(XML文件中). spring的配置 id属性和name属性 id:给bean起个名字,在约束中采用 ID 的约束,唯一,必须以字母开始,可以使用字母.数字.连字符.下划线.句话.冒号,不能出现特殊字符. <bean id=”bookAction”> name:给bean起个名字,没有采用 ID 的约束.name出现特殊字符,

Spring(二)Bean入门

一.BeanFactory介绍 1.1.Bean: 在Spring技术中是基于组件的 最基本了是最常用的单元 其实实例保存在Spring的容器当中 Bean通常被定义在配置文件当中,Bean实例化由Spring的Ioc容器进行管理,Bean的实例可以通过Beanfactory进行访问,实际上大部分J2EE应用,Bean是通过ApplicationContext来访问的,ApplicationContext是BeanFactory的子接口,功能要比BeanFactory强大许多 1.2.BeanF

深究Spring中Bean的生命周期

一.Bean 的完整生命周期 在传统的Java应用中,bean的生命周期很简单,使用Java关键字 new 进行Bean 的实例化,然后该Bean 就能够使用了.一旦bean不再被使用,则由Java自动进行垃圾回收. 相比之下,Spring管理Bean的生命周期就复杂多了,正确理解Bean 的生命周期非常重要,因为Spring对Bean的管理可扩展性非常强,下面展示了一个Bean的构造过程 Bean 的生命周期 如上图所示,Bean 的生命周期还是比较复杂的,下面来对上图每一个步骤做文字描述:

【Spring】的【Bean】管理（注解）【四个相同功能的注解】

[Spring]的[Bean]管理(注解)[四个相同功能的注解] 注解:代码里面特殊的标记,使用注解也可以完成一些相关的功能. 注解写法:@注解名称(属性名称=属性值) 注解使用在类.方法.属性上面 (注解可以替代配置文件,并非完全替代): 1.创建类,创建方法 1 public class User { 2 public void add(){ 3 System.out.println("add-----------"); 4 } 5 } 2.创建spring配置文件,引入约束 1

Spring的Bean管理(注解管理)

Spring注解的IOC入门步骤: 步骤一:下载spring的开发包 http://repo.spring.io/webapp/search/artifact/?0&q=spring-framework 解压:(Spring目录结构:) * docs:API和开发规范. * libs:jar包和源码. * schema:约束. 步骤二:创建Web项目,引入spring开发jar包 核心jar包四个:bean/Core/Context/Expression Language 两个开发包 : log

【SSH三大框架】Spring基础第一篇：搭建Spring环境、实例化Bean、管理Bean的作用域以及Bean的生命周期

一.搭建Spring环境: 在lib目录下引入jar包,然后add to path,这就不过多说了. 二.实例化Bean的三种方式: 首先,我们先写两个java类: 接口类: public interface PersonService { public abstract void save(); } 实现类: public class PersonServiceBean implements PersonService { @Override public void save(){ Syste