二、Spring中的Bean

已于 2023-07-03 09:21:33 修改
阅读量62 收藏
点赞数
分类专栏： SSM 文章标签： spring java eclipse 后端
于 2023-07-01 17:21:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62639288/article/details/131489833
版权

目录

一、Bean的配置

 二、Bean的实例化

1、构造器实例化

2、静态工厂方式实例化

3、实例工厂方式实例化

三、Bean的作用域

 四、Bean的生命周期

五、Bean的装配方式

（1）基于XML的装配

（2）基于注解(Annotation）的装配

一、Bean的配置

如果把Spring看做一个大型工厂，则Spring容器中的Bean就是该工厂的产品。要想使用这个工厂生产和管理Bean，就需要在配置文件中告诉它需要哪些Bean，以及需要使用何种方式将这些Bean装配到一起。
小提示: Bean的本质就是Java中的类，而Spring中的Bean其实就是对实体类的引用，来生产Java类对象，从而实现生产和管理 Bean

 二、Bean的实例化

在面向对象的程序中，想要使用某个对象，就需要先实例化这个对象。同样，在Spring中，要想使用容器中的Bean，也需要实例化Bean。实例化Bean有三种方式，分别为构造器实例化、静态工厂方式实例化和实例工厂方式实例化（其中最常用的是构造器实例化）。
对应Java基础中的创建对象的方式：

假如有一个类Bean1
创建一个Bean1类的对象

（1）Bean1 bean = new Bean1();

（2）Bean1Factory

                //静态
              public static Bean1 creatBean1(){
                  return new Bean1();
             }
         Bean1Factory.creatBean1();//创建Bean1的对象的方法

（3）Bean1Factory

                //非静态
                  public Bean1 creatBean1(){
                        return new Bean1();
                  }
         Bean1Factory bean1factory = new Bean1Factory()；

         bean1factory .creatBean1()；

1、构造器实例化

构造器实例化是指Spring容器通过Bean对应的类中默认的构造函数来实例化Bean。接下来演示构造器实例化的使用:
（1）创建Web项目，导入相关Jar包;
（2）创建名为Bean1的Java类;

/**
 * 空类默认有什么？
 * 1.默认继承了Object类
 * 2.有一个默认无参构造方法
 * */
public class Bean1 {
}

（3）创建Spring配置文件beans1.xml，并配置Beanl实体类Bean;

<?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-4.3.xsd">
        
        <bean id="bean1" class="com.ssm.Bean1" scope="prototype"></bean>
              <!--scope="singleton" 地址相同 scope="prototype" 创建新的 地址不同-->
</beans> 

 

（4）创建测试类，测试程序。

public class Test {
    public static void main(String[] args) {
        //1.加载xml配置文件，初始化容器
        String xmlPath = "com/ssm/Bean1.xml";
        ApplicationContext  applicationContext =

                                        new  ClassPathXmlApplicationContext(xmlPath);
        //2.通过容器获取实例对象
        Bean1 bean1 =(Bean1) applicationcontext.getBean("bean1");

        //3.使用实例对象
        system.out.println(bean1);//    system.out.println(bean1.tostring);
    }

}

（5）输出结果

【com.ssm.Bean1@3a03464】

2、静态工厂方式实例化

静态工厂是实例化Bean的另一种方式。该方式要求自己创建一个静态工厂的方法来创建Bean的实例。接下来演示静态工厂实例化的使用:

（1）创建名为Bean2的Java类;

public class Bean2 {

}

（2）创建一个Java工厂类，在类中使用静态方法获取Bean2实例;

public class MyBean2Factory {
    public static Bean2 createBean2() {
        return new Bean2();
    }

}

（3）创建Spring配置文件beans2.xml，并配置工厂类Bean;

<?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-4.3.xsd">
        
        <bean id="bean2" class="com.ssm.static_factory.MyBean2Factory"
            factory-method="createBean2"></bean>

</beans> 

（4）创建测试类，测试程序。

public class Testioc {
    public static void main(String[] args) {
        //1.加载xml配置文件，初始化容器
        String xmlPath = "com/ssm/static_factory/Bean2.xml";
        ApplicationContext  applicationContext =

                                new ClassPathXmlApplicationContext(xmlPath);
        //2.通过容器获取实例对象
        Bean2 bean2 =(Bean2)applicationContext.getBean("bean2");
        //3.使用实例对象
        System.out.println(bean2);
    }

}

（5）输出结果

【com.ssm.static_factory.Bean2@13a57a3b】

3、实例工厂方式实例化

该方式不再使用静态方法创建Bean实例，而是采用直接创建Bean实例的方法。接下来演示实例工厂方式实例化的使用:

（1）创建名为Bean3的Java类;

public class Bean3 {

}

（2）创建一个Java工厂类，在类中使用非静态方式获取Bean3实例;

public class MyBean3Factory {
    public Bean3 creatBean3() {
        return new Bean3();
    }
}

（3）创建Spring配置文件beans3.xml，并配置工厂类Bean;

<?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-4.3.xsd">
        
        <bean id="myBean3Factory" class="com.ssm.factory.MyBean3Factory"></bean>
 <bean id="bean3" factory-bean="myBean3Factory" factory-method="creatBean3"></bean>

</beans> 

（4）创建测试类，测试程序。

public class Testioc {
    public static void main(String[] args) {
        //1.加载xml配置文件，初始化容器
        String xmlPath = "com/ssm/factory/Bean3.xml";
        ApplicationContext  applicationContext =

                                new ClassPathXmlApplicationContext(xmlPath);
        //2.通过容器获取实例对象
        Bean3 bean3 =(Bean3)applicationContext.getBean("bean3");
        //3.使用实例对象
        System.out.println(bean3);
    }

}

（5）输出结果

【com.ssm.factory.Bean3@13a57a3b】

三、Bean的作用域

singleton和prototype是最常用的两种作用域。【没写默认singleton单例模式】

 四、Bean的生命周期

Spring容器可以管理Bean部分作用域的生命周期。

五、Bean的装配方式

Bean的装配可以理解为依赖关系注入，Bean的装配方式即Bean依赖注入的方式。Spring容器支持多种形式的Bean的装配方式，如基于XML的装配、基于注解(Annotation）的装配和自动装配（其中最常用的是基于注解的装配），将主要讲解这三种装配方式的使用。

（1）基于XML的装配

（1）创建Java类，提供有参、无参构造以及属性setter方法;

【快捷键：右击空白处-->Source-->Generate Constructor using Fields.../
Generate Constructors from Superclass.../Generate Getters and Setters...】
 

public class User {
    private String username;
    private String password;
    private List<String> list;
    public User(String username, String password,List<String> list) {
        super();
        this.username = username;
        this.password = password;
        this.list = list;
    }
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + ", list=" + list + "]";
    }
    

}

（2）创建Spring配置文件beans5.xml，使用2种方式配置Bean;

<?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-4.3.xsd">


     <!--用构造注入方式装配User对象  -->   
       <bean id="user1" class="com.ssm.assemble.User">
       <constructor-arg index="0" value="张三"></constructor-arg>
       <constructor-arg index="1" value="123456"></constructor-arg>
       <constructor-arg index="2">
           <list>
               <value>"张四"</value>
               <value>"张五"</value>
               <value>"张六"</value>
           </list>
       </constructor-arg>
       </bean>
       
       
       <!-- 用设置注入 -->
       <bean id="user2" class="com.ssm.assemble.User">
               <property name="username" value="李四"></property><!--name的值是类的成员属性  -->
               <property name="password" value="654321"></property>
               <property name="list">
                   <list>
                       <value>"李四"</value>
                       <value>"李五"</value>
                       <value>"李六"</value>
                   </list>
               </property>
       </bean>
</beans> 

（3）创建测试类,测试程序。

public class Testioc {
    public static void main(String[] args) {
        //1.加载xml配置文件，初始化容器
        String xmlPath = "com/ssm/assemble/Bean5.xml";
        ApplicationContext  applicationContext =

                         new ClassPathXmlApplicationContext(xmlPath);
        //2.通过容器获取实例对象
        User user1 =(User) applicationContext.getBean("user1");
        //3.使用实例对象
        System.out.println(user1);
        
        User user2 =(User) applicationContext.getBean("user2");
        //3.使用实例对象
        System.out.println(user2);
    }

}

（2）基于注解(Annotation）的装配

基于XML的装配可能会导致XML配置文件过于臃肿，给后续的维护和升级带束一定的困难。为此，Spring提供了对Annotation（注解）技术的全面支持。
@Component:用于描述Spring中的Bean，它是一个泛化的概念，仅仅表示一个组件。
@Repository:用于将数据访问层（DAO）的类标识为Spring中的Bean 。
@Service:用于将业务层(Service）的类标识为Spring中的Bean。
@Controller:用于将控制层(Controller）的类标识为Spring中的Bean

@Autowired:用于对Bean的属性变量、属性的setter方法及构造方法进行标注，配合对应的注解处理器完成Bean的自动配置工作。
@Resource:其作用与Autowired一样。@Resource中有两个重要属性: name和type。Spring将name属性解析为Bean实例名称，type属性解析为Bean实例类型。
@Qualifier:与@Autowired注解配合使用，会将默认的按Bean类型装配修改为按Bean的实例名称装配，Bean的实例名称山@Qualifier注解的参数指定。 
 

---------------------------------------------------------------UserDao.java

public interface UserDao {
    void save();
}

---------------------------------------------------------------UserDaoImpl.java

//@Repository("userDao")--相当于new了对象，不用bean了
@Repository//默认名字是类名首字母小写userDaoImpl
public class UserDaoImpl implements UserDao{

    @Override
    public void save() {
        System.out.println("userDao...save...");
    }

}

------------------------------------------------------------------------UserService.java

public interface UserService {
    void save();
}

--------------------------------------------------------------------------UserServiceImpl.java

//@Service("userService")
@Service
public class UserServiceImpl implements UserService{
    
    //@Resource(name="userDao")//实例对象
    //@Resource
    @Autowired//@Resource和@Autowired都行，经常用Autowired
    private UserDao userDao;//属性

    @Override
    public void save() {
        this.userDao.save();
        System.out.println("userService...save...");
        
    }

}

------------------------------------------------------------------------------------UserController.java

//@Controller("userController")
@Controller
public class UserController {
    
    //@Resource(name="userService")
    @Autowired
    private UserService userService;
    
    public void save() {
        this.userService.save();
        System.out.println("userController...save...");
        
    }
}

-------------------------------------------------------------------------------------Bean6.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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
      <!-- 开启注解，用到context约束 -->
      <context:annotation-config></context:annotation-config> 
       
       
      <!-- <bean id="userDao" class="com.ssm.annotation.UserDaoImpl"></bean>  
      <bean id="userService" class="com.ssm.annotation.UserServiceImpl"></bean>  
      <bean id="userController" class="com.ssm.annotation.UserController"></bean>   -->
      <!-- 扫描包下所有东西 --> 
      <context:component-scan base-package="com.ssm.annotation"></context:component-scan>         
</beans> 

-----------------------------------------------------------------------------------------Testioc.java

public class Testioc {
    public static void main(String[] args) {
        //1.加载xml配置文件，初始化容器
        String xmlPath = "com/ssm/annotation/Bean6.xml";
        ApplicationContext  applicationContext =

                                                 new ClassPathXmlApplicationContext(xmlPath);
        //2.通过容器获取实例对象
        UserController userController =

                                (UserController) applicationContext.getBean("userController");
        userController.save(); 
    }

}

结果

用到的jar包

饭团煲
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring中bean的生命周期详解
08-26
今天小编就为大家分享一篇关于spring中bean的生命周期详解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Bean 的实例化与装配
m0_72151428的博客
09-22 1478
Bean的实例化与装配的实验与讲解
Spring6 - （08） Bean 的实例化方法
chenyouchang的博客
03-26 416
java.util.Date在Spring中被当做简单类型，简单类型在注入的时候可以直接使用value属性或value标签来完成。但我们之前已经测试过了，对于Date类型来说，采用value属性或value标签赋值的时候，对日期字符串的格式要求非常严格，必须是这种格式的：Mon Oct 10 14:30:26 CST 2022。其他格式是不会被识别的。如以下代码：第一步：创建DateBean类} }第二步：配置beans.xml
Spring Bean详细讲解
11-23 6596
什么是Bean? Spring Bean是被实例的，组装的及被Spring 容器管理的Java对象。 Spring 容器会自动完成@bean对象的实例化。 创建应用对象之间的协作关系的行为称为：装配(wiring)，这就是依赖注入的本质。 Spring 三种配置方案 1.在XML中进行显示配置 2.使用Java代码进行显示配置 3.隐式的bean发现机制和自动装配 推荐方式： 3>...
Java bean配置，bean的实例化和生命周期
weixin_46140377的博客
05-02 1031
Java bean配置，bean的实例化和生命周期
Spring中的Bean的实例化
一个真ikun
12-09 1459
本篇总结Bean实例化的三种方式，并配以案例演示
Spring中Bean的生命周期使用解析
08-25
主要介绍了Spring中Bean的生命周期使用解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
详解Spring中bean的几种注入方式
08-27
主要介绍了详解Spring中bean的几种注入方式，主要介绍了4种注入，主要有属性注入、构造函数注入、工厂方法注入，非常具有实用价值，需要的朋友可以参考下
浅谈spring容器中bean的初始化
09-02
下面小编就为大家带来一篇浅谈spring容器中bean的初始化。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Bean创建初始化流程.docx
03-04
Spring Bean创建初始化流程
【Java基础】Spring 中 Bean 的理解与使用
yuxiangdeming的博客
03-07 2万+
一、定义 Bean 是 Spring 框架中最核心的两个概念之一（另一个是面向切面编程 AOP） Spring 官方文档对 bean 的解释是： In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, asse
Spring中的基本知识
zz2230633069的博客
01-19 624
bean标签： 作用： 用于配置对象让spring来创建的。 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。 属性： id：给对象在容器中提供一个唯一标识。用于获取对象。 class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。 scope：指定对象的作用范围。 * singleton :默认值，单例的. * prototype :多例的. * request :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中.
Spring框架中的Bean
chao的博客
04-09 2497
Spring中的Bean是一个非常重要的概念，它可以帮助我们将对象的创建和管理与业务逻辑分离。在Spring中，我们可以使用XML配置文件或注解来创建和管理Bean实例，同时还可以指定Bean实例的作用域，以控制Bean实例的生命周期。希望本篇博客可以帮助大家更好地理解Spring中的Bean，同时也可以通过代码实践来加深对Bean的理解。
Spring中的bean的理解
热门推荐
yss的博客
03-11 9万+
首先看一下spring中创建bean的方式 1. 使用构造器创建Bean实例 使用构造器来创建Bean实例是最常见的情况，如果不采用构造注入，Spring底层会调用Bean类的无参构造器来创建实例，因此要求该Bean提供无参的构造器。在这种情况下，class元素是必须的，class属性的值就是Bean实例的实现类。Spring对Bean实例的所有属性执行默认初始化，即所有基本类型为0或false，...
Spring框架（Bean配置详解）
weixin_43732570的博客
06-22 1万+
前言 我觉得Spring的学习就类似一门新的语言，有属于自己的特性，看着挺简单，但想要掌握就得多敲，每种配置区别不大，对比观察才能更好区别 内容概要 配置形式 配置方式 IOC描述 依赖注入方式 配置形式 配置形式有两种1.基于xml文件；2.基于注解的方式 1.基于xml文件配置 ...
spring框架下获取bean的七种方式总结。
菜鸟的自我积累
06-11 1559
今天进行之前某个项目的优化，发现自己当时对数据库的操作采用了Apache的DBUtils框架，导致存在大量的像获取connection、获取statement、获取resultset、遍历resultset并封装成集合、依次关闭connection,statement,resultset等这些重复操作。这样的代码简直不能忍。基于使用的框架是spring,于是决定使用spring jdbctem
Spring框架中Bean的生命周期及加载顺序
赵英超的博客
04-29 4911
Spring容器中的Bean是有生命周期的 Spring允许在Bean在初始化完成后以及Bean销毁前执行特定的操作，常用的设定方式有以下三种： 通过实现InitializingBean/DisposableBean接口来定制初始化之后/销毁之前的操作方法； 通过<bean>元素的init-method/destroy-method属性指定初始化之后/...
Spring中Bean及@Bean的理解
q540694991的博客
11-18 384
Bean在Spring和SpringMVC中无所不在，将这个概念内化很重要，下面分享一下我的想法：一、Bean是啥1、Java面向对象，对象有方法和属性，那么就需要对象实例来调用方法和属性（即实例化）；2、凡是有方法或属性的类都需要实例化，这样才能具象化去使用这些方法和属性；3、规律：凡是子类及带有方法或属性的类都要加上注册Bean到Spring IoC的注解；4、把Bean理解为类的代理或代言人（
浅析JAVA spring框架中的Bean
qq_40893331的博客
11-29 1688
@Bean在Spring和SpringMVC中无所不在，将这个概念内化很重要， 下面分享一下我的想法： 一、Bean是啥 1、Java面向对象，对象有方法和属性，那么就需要对象实例来调用方法和属性（即实例化）； 2、凡是有方法或属性的类都需要实例化，这样才能具象化去使用这些方法和属性； 3、规律：凡是子类及带有方法或属性的类都要加上注册Bean到Spring IoC的注解；（@Component ...
简述spring中bean
最新发布
07-28
在Spring框架中，Bean是指被Spring容器管理的对象。它是Spring的核心概念之一，用于表示应用程序中的各种组件、服务和对象。 Spring提供了一个容器（ApplicationContext）来管理和配置这些Bean。Bean可以通过XML...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值