Spring框架之bean的作用范围及生命周期的注解

最新推荐文章于 2024-05-13 15:54:28 发布
最新推荐文章于 2024-05-13 15:54:28 发布
阅读量293 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46466568/article/details/109764798
版权

Spring框架之bean的作用范围及生命周期的注解

Bean的作用范围注解  
	* 注解为@Scope(value="prototype")，作用在类上。值如下：
		* singleton		-- 单例，默认值
		* prototype		-- 多例

Bean的生命周期的配置（了解）作用在方法上
	* 注解如下：
		* @PostConstruct	-- 相当于init-method
		* @PreDestroy		-- 相当于destroy-method
		
		例如:
		@PostConstruct
		public void init(){
			System.out.println("serivce初始化方法执行了");
		}

案例演示

  1. 创建maven项目，在pom.xml中引入所需的依赖

    <dependencies>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <scope>compile</scope>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.1.2</version>
    </dependency>
    <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.7</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

2，创建一张account表

create table account(
	id int primary key auto_increment,
	name varchar(40),
	money float
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);

3.开始分包创建相应的类

在com.itheima.bean包中创建Account实体类 Account.class

  public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
    //get set 方法略，自己补上
}

4.在service包中创建接口IAccountService，提供crud的方法

public interface IAccountService {
    List<Account> findAll();//查询所有
    Account findAccountByID(Integer id);//根据id查询一个
    void saveAccount(Account account);//保存
    void updateAccount(Account account);//更新
    void deleteAccountByID(Integer id);//根据id删除
}

  1. 写一个该接口的实现类IAccountServiceImpl，然后具体去实现crud的操作

  2. 在Dao包中创建IAccountDao 接口

     public interface IAccountDao {
    List<Account> findAll();//查询所有

    Account findAccountByID(Integer id);//根据id查询一个

    void saveAccount(Account account);//保存

    void updateAccount(Account account);//更新

    void deleteAccountByID(Integer id);//根据id删除
}

7.创建IAccountDao接口的实现类 IAccountDaoImpl

8.在IAccountServiceImpl中提供 IAccountDao dao 并提供set方法

 public class IAccountServiceImpl implements IAccountService {
    
    IAccountDao dao;

    public void setDao(IAccountDao dao) {
        this.dao = dao;
    }
    //其他方法 略
}
  1. 在IAccountServiceImpl 中的方法中，调用dao中的方法
此处只展示一个
 public List<Account> findAll() {
        List<Account> list = dao.findAll();
        return list;
    }

10.在IAccountDaoImpl中提供 QueryRunner 的引用并提供set方法 使用他来完成crud操作，因为queryRunner只能采用构造方法的办法来提供注入依赖

QueryRunner queryRunner;

    public QueryRunner getQueryRunner() {
        return queryRunner;
    }

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }
 public List<Account> findAll() throws SQLException {
       // System.out.println(queryRunner);
        List<Account> list = queryRunner.query("select * from account", new BeanListHandler<Account>(Account.class));
        return list;

    }

11.在resources目录下 创建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: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">
   <!--配置数据源-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <!--配置四个属性值-->
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
        <property name="jdbcUrl" value="jdbc:mysql:///spring_test"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    </bean>
    <!--配置QueryRunner-->
    <bean class="org.apache.commons.dbutils.QueryRunner" id="queryRunner">
<!--注入数据源，只能采用构造的方法注入-->
        <constructor-arg name="ds" ref="dataSource"/>
    </bean>
    <!--配置Dao-->
    <bean class="com.itheima.dao.IAccountDaoImpl" id="accountDao">
        <property name="queryRunner" ref="queryRunner"/>
    </bean>
    <!--配置service-->
    <bean class="com.itheima.service.IAccountServiceImpl" id="accountService">
    <!--注入Dao-->
        <property name="accountDao" ref="accountDao"/>
    </bean>


</beans>

13.编写测试类，测试我们的crud 操作

public class MyTest {
    @Test
    public void testFindAll() throws SQLException {
        //读取配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContect.xml");
       // Object accountService = context.getBean("accountService");
        IAccountService accountService = context.getBean("accountService", IAccountService.class);
        List<Account> list = accountService.findAll();
        for (Account account : list) {
            System.out.println(account);
        }


    }
}
开始使用注解的方式对上面的案例进行改造
  1. 使用注解的时候需要新的约束
<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">
</beans>

2.使用注解需要开启注解扫描

 <!--使用注解需要开启注解扫描-->
  <context:component-scan base-package="com.itheima">
  </context:component-scan>

3.可以删除 dao和service的配置 只留下下面的

 <!--使用注解需要开启注解扫描-->
  <context:component-scan base-package="com.itheima">
  </context:component-scan>
   <!--配置数据源-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <!--配置四个属性值-->
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
        <property name="jdbcUrl" value="jdbc:mysql:///spring_test"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    </bean>
    <!--配置QueryRunner 配置成多例的-->
    <bean class="org.apache.commons.dbutils.QueryRunner" id="queryRunner" scope="prototype">
<!--注入数据源，只能采用构造的方法注入-->
        <constructor-arg name="ds" ref="dataSource"/>
    </bean>

4.在dao和service 上添加注解 并注入要使用的对象

@Repository(value = "accountDao")
public class IAccountDaoImpl implements IAccountDao {
    @Autowired  //自动注入 采用注解注入set方法可以省略不写
    QueryRunner queryRunner;  
    ...
  }
  
@Service(value = "accountService")
public class IAccountServiceImpl implements IAccountService {
    @Autowired  //注入dao
    IAccountDao dao;
    ...
}

5.测试

使用Spring的新注解，完全替代applicationContext.xml中的配置

  1. 在com.itheima.config 包下新创建一个类 SpringConfig这个类就相当于要替代applicationContext.xml 这个配置文件。

  2. 在这个SpringConfig类上添加一个新的注解 @Configuration代表这是一个配置类

    @Configuration
public class SpringConfig {

}

  3. 我们再想办法把applicationContext.xml配置文件中的那行注解扫描，也使用注解的方式替代掉
    <context:component-scan base-package=“org.westos”></context:component-scan>
    怎么替代上面这行注解扫描呢？
    我们可以使用一个新的注解@ComponentScan 表示通过此注解指定spring在容器时要扫描的包
    @ComponentScan(basePackages = “org.westos”)
    @ComponentScan(value = “org.westos”)
    这里ComponentScan注解的属性 value和basePackages 意思是一样的，使用哪个都行
    例子：

    
@Configuration
@ComponentScan(value = "com.itheima")//注解扫描
public class SpringConfig {
}

  4. 我们接下来再想办法，把applicationContext.xml中的下面这个配置，也想办法替换掉

    <bean class="org.apache.commons.dbutils.QueryRunner" id="queryRunner" scope="prototype">
           <!--注入数据源，只能使用构造方法注入-->
           <constructor-arg name="ds" ref="dataSource"></constructor-arg>
       </bean>

    也就是把创建 QueryRunner对象的操作使用注解替换掉

    我们在SpringConfig这个配置类中，提供一个方法，方法的返回值，就是返回一个QueryRunner对象

    如果我们仅仅只是提供了这么一个方法，方法返回一个QueryRunner对象，但是这个对象并没有放到spring容器中
    所以我们还得在方法上使用一个注解 @Bean 表示把这个方法返回的这个对象，放到spring容器中
    @Bean 这个注解有一个属性 name 表示用于指定bean的id，如果不写默认的值是当前方法的名称也就是 name的默认值是createQueryRunner 这个方法名


@Configuration
@ComponentScan(value = "com.itheima")//注解扫描
public class SpringConfig {
    @Bean(name = "queryRunner")
   public QueryRunner createQueryRunner(DataSource dataSource){

       return new QueryRunner(dataSource);//new 一个QueryRunner对象返回
   }

5.我们采用同样的方式，替换掉applicationContext.xml中数据源的配置

​ 我们在SpringConfig这个配置类中，提供一个方法，方法的返回值是一个数据源对象

 @Bean(value = "dataSource")//把返回的数据源对象，放到spring容器中
    public DataSource createComboPooledDataSource() throws PropertyVetoException {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        ds.setDriverClass("com.mysql.jdbc.Driver");
        ds.setJdbcUrl("jdbc:mysql:///spring_test");
        ds.setUser("root");
        ds.setPassword("123456");
        return ds;
    }

6.上面的操作做完之后，我们 applicationContext.xml 中配置的内容就可以删了

  1. 我们可以把applicationContext.xml这个配置文件删了，但是删了，我们要使用
    AnnotationConfigApplicationContex 这个类，来加载我们的SpringConfig这个类中的注解配置.
  2. 测试
@Test
    public void testFindAll() throws SQLException {
       //传入我们配置类的字节码对象
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        //获取dao对象
        IAccountDao dao = context.getBean("accountDao", IAccountDao.class);
        List<Account> list = dao.findAll();
        for (Account account : list) {
            System.out.println(account);
        }

9.代码优化

创建数据源的时候发现四个基本参数是写死的，我们可以将参数抽离到一个配置文件中，那么我们在resources目录下创建一个jdbcConfig.properties 配置文件，内容如下

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_test
jdbc.username=root
jdbc.password=123456

10.我们也可以设置多个配置类比如把SpringConfig这个类设置为一个主配置类，他里面比如可以设置一些公共的配置，然后我们在创建一个配置类比如 JDBCConfig这个配置类，然后我们把主配置类里面的配置拿到JDBCConfig这个配置类当中 如下

public class JDBCConfig {
    @Bean(name = "queryRunner")
    @Scope(value = "prototype") //配置成多例的
    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    @Bean(name = "dataSource")
    public DataSource createComboPooledDataSource() throws PropertyVetoException {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        ds.setDriverClass("com.mysql.jdbc.Driver");
        ds.setJdbcUrl("jdbc:mysql:///spring_test");
        ds.setUser("root");
        ds.setPassword("123456");
        return ds;
    }
}

那么这时候我们主配置类中没有了配置
@Configuration
@ComponentScan(basePackages = "ocom.itheima")
public class SpringConfig {

}
我们的测试代码，是加载的主配置类
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); //传入我们配置类的字节码对象
所以我们应该在主配置类中导入子配置类，怎么导入？使用一个 @Import(value = JDBCConfig.class) 的注解
注意该注解的value属性要的是一个 .class 类型，不是字符串类型
@Configuration
@ComponentScan(basePackages = "com.itheima")
@Import(value = JDBCConfig.class) //导入子配置类的字节码对象
public class SpringConfig {

}

然后我们再在JDBCConfig类中提供四个成员变量
然后在成员变量上面使用@Value注解来读取jdbcConfig.properties中的配置
然后在创建数据源的方法中直接使用四个成员变量
如下：

public class JDBCConfig {
 	//注意这里的键的名称要和jdbcConfig.properties文件中的键名保持一致
    @Value(value = "${jdbc.driver}")
    private String driverClass;
    @Value(value = "${jdbc.url}")
    private String jdbcUrl;
    @Value(value = "${jdbc.username}")
    private String user;
    @Value(value = "${jdbc.password}")
    private String password;
    @Bean(name = "queryRunner")
    @Scope(value = "prototype") //配置成多例的
    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }
     @Bean(name = "dataSource")
    public DataSource createComboPooledDataSource() throws PropertyVetoException {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        //使用成员变量的值
        ds.setDriverClass(driverClass);
        ds.setJdbcUrl(jdbcUrl);
        ds.setUser(user);
        ds.setPassword(password);
        return ds;
    }
}

可以使用一个注解 @PropertySource 来读取

@PropertySource(value = "classpath:jdbcConfig.properties")

代码如下：
@Configuration
@ComponentScan(basePackages = "com.itheima")
@Import(value = JDBCConfig.class) //导入子配置类的字节码对象
@PropertySource(value = "classpath:jdbcConfig.properties") //读取类路径下的配置文件
public class SpringConfig {

}
cherry...a
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
@config注解中bean的作用
别抢我蓝buff
02-29 942
其实这个就是在容器中声明的作用 这样的话就可以在其他声明在spring容器的类中直接调用 所以一般会给bean加名字 直接调用名字即可 更通俗的理解就是把它理解为一个常量 然后直接调用 ...
深入了解Spring中Bean的作用域和生命周期
08-25
在 Spring 框架中，Bean 的作用域和生命周期是两个非常重要的概念，它们决定了 Bean 的实例化和生命周期。了解 Spring 中 Bean 的作用域和生命周期是非常重要的，这将有助于开发者更好地使用 Spring 框架。 Bean 的...
@bean的作用？
weixin_44943389的博客
06-27 2709
注解的作用是将一个方法返回的对象注册为一个 Bean，使其可以被 Spring 容器管理，并提供依赖注入和自定义配置的功能。依赖注入：当其他组件需要使用这个 Bean 时，Spring 框架会自动将该 Bean 注入到相应的位置，实现依赖注入。注解可以将方法返回的对象注册为一个 Bean，并且该 Bean 会被 Spring 容器管理。是一个注解，用于告诉 Spring 框架将标注的方法返回的对象注册为一个 Bean（组件）。注解可以对 Bean 进行自定义配置，例如设置属性值、初始化方法、销毁方法等。
no qualifying bean of type_就是要让你彻底学会 @Bean 注解
weixin_39989384的博客
11-24 673
推荐阅读(点击即可跳转阅读)1. SpringBoot内容聚合2. 面试题内容聚合3. 设计模式内容聚合4. 排序算法内容聚合5. 多线程内容聚合@Bean 注解全解析随着SpringBoot的流行，基于注解式开发的热潮逐渐覆盖了基于XML纯配置的开发，而作为Spring中最核心的bean当然也能够使用注解的方式进行表示。所以本篇就来详细的讨论一下作为Spring中的Bean到底都有哪些用法。@B...
@Bean注解的作用
最新发布
wgx_0504的博客
05-13 425
如果在相同的配置类中定义了两个方法，且这两个方法上都使用了 @Bean 注解，并且这两个方法返回的对象类型完全相同，那么默认情况下，Spring 会根据方法的名称来注册这两个 bean，因此不会出现错误。请注意，即使你有相同的代码，但如果你希望定义不同的 bean（例如，具有不同配置或状态的实例），那么你可能需要调整你的代码结构或使用工厂模式来生成不同的实例。使用不同的方法名称：如上例所示，通过定义不同的方法并使用 @Bean 注解，Spring 会根据方法名称来注册不同的 bean。
@Bean注解详解
怪咖@的博客
10-20 3万+
@Bean属于spring当中的注解，@Bean用于将对象存入spring的ioc容器中，同`@controller、@Service、@Component、@Configuration`等几个注解是一样的，都是负责`将对象存入容器当中`。只不过方式不同，他们是用在类上面的，然后将当前类`通过无参构造函数创建对象`然后放入容器，而`@Bean`是用在方法上，将当前方法的`返回值对象`放到容器当中！可以理解为前者是由spring自动创建对象，而@Bean创建对象是交给我们自己来控制。
spring官网下载方法
u010330144的专栏
06-17 1559
不废话，直接上步骤1，进入Spring官网：https : //spring.io/ 点击PROJECTS，进入下一个页面 2，点击  SPRING FRAMEWORK 图标，进入下一页面3，点击一个小猫的图标，进入github页面，然后在页面底部找到一个Spring Framework Artifacts 超链接4，点击SpringFramework Artifacts超链接，跳转到下一个页面，...
详解Java的Spring框架中bean的定义以及生命周期
09-03
总的来说，理解并掌握Spring框架中Bean的定义和生命周期对于Java Web开发至关重要。它不仅涉及到Bean的创建、初始化和销毁，还涉及到Bean间的依赖注入、生命周期管理以及各种扩展机制，这些都是构建可维护、可扩展的...
spring之Bean的生命周期详解
08-30
Spring框架中的Bean生命周期是指Bean从创建到销毁的整个过程。该过程包括Bean的定义、初始化、使用和销毁四个阶段。 Bean的定义 在Spring框架中，Bean是指一个可重用的Java类，通常用来封装业务逻辑或数据访问逻辑...
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
spring bean的生命周期
01-16
Spring Bean的生命周期是Spring框架中的核心概念，它涵盖了Bean从创建到销毁的全过程。了解这一过程对于优化应用程序的性能和管理资源至关重要。在Spring中，Bean的生命周期主要分为以下几个阶段： 1. **初始化阶段...
@Bean 注解的作用
tfish的专栏
06-26 3731
被 @Bean 注解标注的方法会创建一个 bean 的实例，放在 spring IoC 容器中。等需要使用这个 bean 的时候，在类里用 @Autowired，@Resource 注入这个对象就行了。 @Bean public AccountDao accountDao() { return new AccountDao(); } ...
Spring（1）—maven依赖、IOC、Spring配置说明、依赖注入、bean的作用域
weixin_42182892的博客
08-22 936
一、搭建环境 1、maven spring依赖 <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>
Spring中Bean的理解以及@Bean的作用
建建的博客
09-02 3635
Bean在Spring和SpringMVC中无所不在，将这个概念内化很重要，下面分享一下我的想法： 一、Bean是啥 1、Java面向对象，对象有方法和属性，那么就需要对象实例来调用方法和属性（即实例化）； 2、凡是有方法或属性的类都需要实例化，这样才能具象化去使用这些方法和属性； 3、规律：凡是子类及带有方法或属性的类都要加上注册Bean到Spring IoC的注解； 4、把Bean理解为类的代理或代言人（实际上确实是通过反射、代理来实现的），这样它就能代表类拥有该拥有的东西了
Spring中运用注解实现ioc
Remvery的博客
11-13 321
使用注解实现iocJavaSpring框架学习第二天笔记2 JavaSpring框架学习第二天笔记2 用于创建对象的 他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的 Component: 作用：用于把当前类对象存入spring容器中 属性： value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。 Controller：一般用在表现层 Servic.
Spring（10）——bean作用范围
Elim的博客
07-21 1万+
10 bean作用范围（scope）在Spring中使用Scope来表示一个bean定义对应产生实例的类型，也可以说是对应实例的作用范围。Spring内置支持的scope严格来说默认是有五种，分别是：singleton：这是默认Scope，表示在整个bean容器中或者说是整个应用中只会有一个实例。prototype：多例类型，表示每次从bean容器中都会获取到一个对应bean定义全新的实例。req
Spring Bean的作用域
热门推荐
forever-and-ever的博客
08-25 6万+
在Spring中，bean作用域用于确定哪种类型的bean实例应该从Spring容器中返回给调用者。 目前Spring Bean的作用域或者说范围主要有五种。 作用域 描述 singleton 在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，bean作用域范围的默认值。 prototype 每次从容器中调用Bean时，都返回一个新的实例，即每...
Bean的作用范围的配置（重点）
09-26 258
​​Bean的作用范围的配置 scope属性 ：Bean的作用范围 singleton ：默认的，Spring会采用单例模式创建这个对象。 prototype ：多例模式。（Struts2和Spring整合一定会用到） request ：web项目中，Spring创建这个类以后，将这个类存入到request范围中。 sessio...
Spring框架中Bean的生命周期
05-25
Spring框架中Bean的生命周期一般包括以下阶段： 1. 实例化Bean对象：容器根据配置文件或注解等方式创建Bean的实例。 2. 设置Bean属性值：容器将配置文件或注解中的属性值设置到Bean实例中。 3. 调用Bean初始化方法：容器调用Bean实例中的初始化方法，可以通过@PostConstruct注解或实现InitializingBean接口来指定初始化方法。 4. Bean可以使用：容器将Bean实例交给应用程序使用。 5. 调用Bean销毁方法：容器在销毁Bean实例前调用Bean实例中的销毁方法，可以通过@PreDestroy注解或实现DisposableBean接口来指定销毁方法。 6. 销毁Bean对象：容器销毁Bean实例。 以上是Spring框架中Bean的典型生命周期，需要注意的是，Bean的生命周期可以通过自定义扩展点进行扩展，例如BeanPostProcessor接口可以在Bean实例化、属性设置完毕前后、初始化方法调用前后等多个阶段对Bean进行加强处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值