Spring常用的配置

最新推荐文章于 2024-04-07 14:28:16 发布
最新推荐文章于 2024-04-07 14:28:16 发布
阅读量193 收藏
点赞数
分类专栏： —— Spring 文章标签： java spring scope javaee 配置
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41293896/article/details/103482271
版权

Bean的Scope

一、介绍

Scope描述的是Spring容器是如何新建Bean的实例。

Singleton：一个Spring容器只有一个实例。

Prototype：每次调用都会新建一个Bean的实例。

二、需求

Singleton和Prototype，分别从Spring容器中获得两次Bean，判断是否相等

三、示例
1.编写Singleton的Bean
package com.eleven.scope1;

import org.springframework.stereotype.Service;

@Service // 表示当前类是Spring管理的一个Bean
// @Scope("singleton") 默认为Singleton,所以注释掉
public class DemoSingletonService {

}
2.编写Prototype的Bean
package com.eleven.scope1;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

@Service // 表示当前类是Spring管理的一个Bean
@Scope("prototype") // 声明scope为prototype
public class DemoPrototypeService {

}
3.配置类
package com.eleven.scope1;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration // 声明当前类是一个配置类
@ComponentScan("com.eleven.scope1") // 自动扫描包下面的所有配置
public class ScopeConfig {

}
4.运行
package com.eleven.scope1;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
	public static void main(String[] args) {
		// 声明AnnotationConfigApplicationContext是Spring管理的一个Bean，将ScopeConfig注入进去
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ScopeConfig.class);

		// 获取DemoSingletonService声明的Bean
		DemoSingletonService s1 = context.getBean(DemoSingletonService.class);
		DemoSingletonService s2 = context.getBean(DemoSingletonService.class);

		DemoPrototypeService p1 = context.getBean(DemoPrototypeService.class);
		DemoPrototypeService p2 = context.getBean(DemoPrototypeService.class);

		System.out.println("Singleton：s1和s2是否相等：" + s1.equals(s2));
		System.out.println("Prototype:p1和p2是否相等：" + p1.equals(p2));

		context.close();

	}

}
5.输出
Singleton：s1和s2是否相等：true
Prototype:p1和p2是否相等：false

Spring EL和资源调用

一、介绍

支持在xml和注解里面使用表达式，可以利用Spring的表达式语言实现资源注入。

二、需求

使用Spring注入以下内容：（1）字符串（2）操作系统属性（3）表达式运算结果（4）其它Bean属性（5）文件内容（6）网址内容（7）属性文件

三、示例
1.pom文件中添加commons-io的依赖
<!-- 将file转化成字符串 -->
		<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>2.3</version>
		</dependency>
2.新建test.txt文件，内容随意
wqewrhigndfvalmf
文件高级工我按揭我给你
！@#￥%……&*（）——
3.新建test.properties
study.author=eleven
study.name=spring boot
4.需要注入的Bean
package com.eleven.el;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service // 使用注解声明表示DemoService类是Spring管理的一个Bean
public class DemoService {

	@Value("其它类的属性") // 此处为注入普通字符串
	private String another;

	/** get和set */
	public String getAnother() {
		return another;
	}

	public void setAnother(String another) {
		this.another = another;
	}

}
5.配置类
package com.eleven.el;

import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;

@Configuration	// 声明该类是一个配置类
@ComponentScan("com.eleven.el")	// 自动扫描包下面的所有注解
@PropertySource("classpath:com/eleven/el/test.properties")	// 注入配置文件
public class ElConfig {
	
	@Value("I Love You!")	// 注入普通字符串
	private String normal;
	
	@Value("#{systemProperties['os.name']}")	// 注入操作系统属性
	private String osName;
	
	@Value("#{T(java.lang.Math).random() *100.0}")	// 注入表达式结果
	private double randomNumber;
	
	@Value("#{demoService.another}")	// 注入其它Bean属性
	private String fromAnother;
	
	@Value("classpath:com/eleven/el/test.txt")	// 注入文件资源
	private Resource testFile;
	
	@Value("https://www.baidu.com")	// 注入网址资源
	private Resource testUrl;
	
	@Value("${study.name}")	// 注入配置文件
	private String studyName;
	
	@Autowired	// 将Environment注入到ElConfig里面	
	private Environment environment;	// 注入配置文件
	
	@Bean	// 表示当前方法的返回值是一个Bean 
	public static PropertySourcesPlaceholderConfigurer propertyConfigurer() {
		return new PropertySourcesPlaceholderConfigurer();
	}

	public void outputResource() {
		try {
		System.out.println(normal);
		System.out.println(osName);
		System.out.println(randomNumber);
		System.out.println(fromAnother);
		System.out.println(IOUtils.toString(testFile.getInputStream()));
		System.out.println(IOUtils.toString(testUrl.getInputStream()));
		System.out.println(studyName);
		System.out.println(environment.getProperty("study.author"));
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}
6.运行
package com.eleven.el;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ElConfig.class);

		ElConfig resourceSevice = context.getBean(ElConfig.class);
		resourceSevice.outputResource();
		context.close();
	}

}
7.输出
I Love You!
Windows 10
94.68825963827781
其它类的属性
wqewrhigndfvalmf
文件高级工我按揭我给你
！@#￥%……&*（）——
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta http-equiv=content-type content=text/html;charset=utf-8><meta http-equiv=X-UA-Compatible content=IE=Edge><meta content=always name=referrer><link rel=stylesheet type=text/css href=https://ss1.bdstatic.com/5eN1bjq8AAUYm2zgoY3K/r/www/cache/bdorz/baidu.min.css>......

spring boot

eleven

Bean的初始化和销毁

一、介绍

Spring对Bean的生命周期提供了支持，共有2种方式。

二、需求

用Java配置的方式和注解的方式来描述Bean的初始化和销毁。

三、示例
1.pom文件中添加JSR250支持
<!-- Java规范提案 -->
		<!-- https://mvnrepository.com/artifact/javax.annotation/jsr250-api -->
		<dependency>
			<groupId>javax.annotation</groupId>
			<artifactId>jsr250-api</artifactId>
			<version>1.0</version>
		</dependency>
2.使用Java配置的形式的Bean
package com.eleven.beaninitdestory1;

public class BeanWayService {

	public void init() {
		System.out.println("Bean初始化该方法");
	}

	public BeanWayService() {
		super();
		System.out.println("初始化构造函数");
	}

	public void destroy() {
		System.out.println("Bean销毁该方法");
	}

}
3.使用JSR250形式的Bean
package com.eleven.beaninitdestory1;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class JSR250WayService {

	@PostConstruct
	public void init() {
		System.out.println("jsr250初始化该方法");
	}

	public JSR250WayService() {
		super();
		System.out.println("初始化构造函数");
	}

	@PreDestroy
	public void destroy() {
		System.out.println("jsr250销毁该方法");
	}

}
4.配置类
package com.eleven.beaninitdestory1;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration // 声明当前类是一个配置类
@ComponentScan("com.eleven.beaninitdestory1") // 自动扫描包下面的所有配置
public class PrePostConfig {

	@Bean(initMethod = "init", destroyMethod = "destroy") // 初始化的方法和销毁的方法都是对应BeanWayService里面的方法
	BeanWayService beanWayService() {
		return new BeanWayService();
	}

	@Bean
	JSR250WayService jsr250WayService() {
		return new JSR250WayService();
	}

}
5.运行
package com.eleven.beaninitdestory1;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PrePostConfig.class);

		// Java配置
		BeanWayService beanWayService = context.getBean(BeanWayService.class);

		// 注解配置
		JSR250WayService jsr250WayService = context.getBean(JSR250WayService.class);

		context.close();
	}

}
6.输出
初始化构造函数
jsr250初始化该方法
初始化构造函数
Bean初始化该方法
十二月 04, 2019 5:17:39 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@5e9f23b4: startup date [Wed Dec 04 17:17:39 CST 2019]; root of context hierarchy
Bean销毁该方法
jsr250销毁该方法

Profile

一、介绍

Profile表示可以在不同环境下使用不同的配置。

二、需求

通过使用Profile注解，来配置生产/开发环境。

三、示例
1.示例Bean
package com.eleven.profile;

public class DemoBean {

	private String content;

	public DemoBean(String context) {
		super();
		this.content = context;
	}

	/** get/set方法 */
	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}
}
2.Profile配置
package com.eleven.profile;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration // 声明当前类是一个配置类
public class ProfileConfig {

	@Bean	// 表示当前类的返回值就是一个Bean
	@Profile("dev")
	public DemoBean devDemoBean() {
		return new DemoBean("开发环境");
	}

	@Bean
	@Profile("prod")
	public DemoBean prodDemoBean() {
		return new DemoBean("生产环境");
	}

}
3.运行
package com.eleven.profile;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

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

		// 使用AnnotationConfigApplicationContext作为Spring的容器
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		// 通过设定Environment的ActiveProfiles来设定当前context的配置环境
		context.getEnvironment().setActiveProfiles("prod"); // 先将活动的Profile设置为Prod
		// context.getEnvironment().setActiveProfiles("dev"); // 表示开发环境
		context.register(ProfileConfig.class); // 注册Bean的配置类
		context.refresh(); // 刷新容器
		// 获得DemoBean声明的Bean
		DemoBean demoBean = context.getBean(DemoBean.class);
		System.out.println(demoBean.getContent());
		context.close();
	}

}
4.输出
生产环境

事件（Application Event）

一、介绍

Spring的事件为Bean和Bean之间的消息通信提供了支持。

当一个Bean处理完一个任务之后，希望能够被其它Bean知道并作出相应的处理，这时，我们就需要让其它Bean监听当前Bean所发送的事件。

二、需求

1.自定义事件，集成ApplicationEvent。

2.定义事件监听器，实现ApplicationListener。

3.使用容器发布事件。

三、示例
1.自定义事件
package com.eleven.event;

import org.springframework.context.ApplicationEvent;

public class DemoEvent extends ApplicationEvent {

	private static final long serialVersionUID = 1L;
	private String msg;

	/** get/set **/
	public DemoEvent(Object source, String msg) {
		super(source);
		this.msg = msg;
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

}
2.定义事件监听器
package com.eleven.event;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component	// 将普通的pojo对象实例化到Spring容器中
public class DemoListener implements ApplicationListener<DemoEvent> { // 实现了ApplicationListener接口，并指定监听事件的类型

	@Override
	public void onApplicationEvent(DemoEvent event) {	// 使用onApplicationEvent方法对消息进行接收处理

		String msg = event.getMsg();

		System.out.println("我（bean-demoListener）接收到了bean-demoPublisher发布的消息：" + msg);

	}

}
3.使用容器发布事件
package com.eleven.event;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class DemoPublisher {

	@Autowired	// 将ApplicationContext注入到当前类中
	ApplicationContext applicationContext; // 注入ApplicationContext用来发布事件

	public void publish(String msg) {
		applicationContext.publishEvent(new DemoEvent(this, msg)); // 使用ApplicationContext的PublishEvent方法来发布
	}
}
4.配置类
package com.eleven.event;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration	// 声明当前是一个配置类
@ComponentScan("com.eleven.event")	// 自动扫描包下面所以的配置
public class EventConfig {

}
5.运行
package com.eleven.event;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
	public static void main(String[] args) {
		// 将AnnotationConfigApplicationContext作为Spring的容器，并将参数配置进去
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(EventConfig.class);
		// 获得DemoPublisher的声明Bean
		DemoPublisher demoPublisher = context.getBean(DemoPublisher.class);
		// 发布消息
		demoPublisher.publish("Hello Application Event");
		context.close();
	}

}
6.输出
我（bean-demoListener）接收到了bean-demoPublisher发布的消息：Hello Application Event
zzzzzzzzzzzw___
关注
专栏目录
【微服务】spring读取配置文件多种方式深入详解
congge
04-21 7739
spring读取配置文件多种方式深入详解
Spring Cloud Config 配置刷新
张人杰的博客
05-03 1143
https://www.cnblogs.com/hfultrastrong/p/8562320.htmlSpring Cloud Config 配置刷新客户端进行刷新操作。1、添加 actuator包，这样 /refresh url才处于可用状态。1234&lt;dependency&gt;    &lt;groupId&gt;org.springframework.boot&lt;/groupI...
spring中的所有配置
12-16
spring 配置 监听 过滤 容器
Spring的常用配置
qmy909的博客
04-07 294
在构造方法之后Bean销毁之前在构造函数之后执行在Bean销毁之前执行。
spring常用配置
huofuman960209的博客
09-18 3631
Spring框架本身四大原则 1.使用POJO进行轻量级以及最小侵入式开发 2.通过依赖注入和基于接口式编程实现松耦合 3.通过AOP和默认习惯进行声明式编程 4.使用AOP和模板（template）减少模式化代码 控制反转和依赖注入在Spring环境下市等同的概念。 常用配置 Bean的Scope 描述Spring如何新建Bean的实例，与模式相似，由@Scope注解实现。如：@...
Spring中常用的配置/方法
S mile0804的博客
02-04 817
1、引入Apache Commons Lang包 commons lang包是日常开发中，可以参考和借助的工具包，其包含null safe安全操作 比较常用的工具类有： ArrayUtils:数组工具类，提供数组拷贝、查找、反转等功能 StringUtils:提供字符串操作，对null是安全的，字符串查找、替换、分割、去空格等操作 ObjectUtils:对null进行安全处理 RandomUtils:随机数工具类,获得随机整数、小数、字符串等 NumberUtils:数值工具类，数值类型转换等操作
spring两种常用的配置文件方式
chorpin214的专栏
01-25 217
在项目中会涉及到多个spring的配置文件，在我所接触的项目中，只用到了两种不同的方法进行配置，有其他好办法的，欢迎讨论。 方法一： 在web.xml文件中作如下配置： contextConfigLocation /WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml ...
Spring常用配置及解析类说明
08-28
Spring常用配置及解析类说明 Spring Framework是当前最流行的Java EE应用程序框架之一，它提供了强大的配置机制，允许开发者灵活地配置应用程序。春天的配置机制是基于XML文件的，它提供了多种配置方式，包括基于...
Spring Boot RabbitMQ常用配置
最新发布
04-21
RabbitMQ 是一个开源的消息代理中间件，广泛用于构建分布式应用程序中的消息系统。在 Spring Boot 项目中，通过集成 RabbitMQ，可以实现异步消息传递、消息队列等功能，提高系统的可靠性和扩展性。
详解spring security 配置多个AuthenticationProvider
08-30
Spring Security 配置多个 AuthenticationProvider 详解 Spring Security 是一个功能强大且灵活的安全框架，提供了多种身份验证机制和访问控制机制。在实际开发中，我们经常需要配置多个身份验证提供程序...
Spring Boot读取配置文件常用方式
10-21
以下将详细介绍Spring Boot读取配置文件的常用方法。 1. **属性文件** Spring Boot默认支持两种主要的属性文件格式：`application.properties`和`application.yml`。前者使用键值对形式，后者使用YAML（YAML Ain't...
Spring三种配置方式
sky198989的博客
02-03 290
转载：https://blog.csdn.net/qq_35744081/article/details/94986758
Spring的配置
jjqqff_123的博客
06-26 133
、.....................................这个是配置数据库*************************************************&lt;!-- Spring的配置文件，这里主要配置和业务逻辑有关的 --&gt; &lt;!--=================== 数据源，事务控制，xxx ================--&gt; ...
Spring的详细介绍与配置
qq_61507300的博客
03-09 653
Spring的详细介绍与超详细代码讲解配置
SSM --Spring 第一天
qq_38288937的博客
09-21 655
1. spring概述 1.1 Spring是什么（理解） Spring是分层的 Java SE/EE应用 full-stack(全栈的，什么都会的，管家的 ) 轻量级开源框架，以 IoC：反转控制和 AOP：面向切面编程 为内核。 sring提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三...
Spring的一些基本配置
weixin_44832141的博客
08-16 231
Spring 配置
Spring常用配置示例
weixin_30955617的博客
08-25 71
Spring是一款Java平台的开源框架，是为解决企业级应用程序开发的复杂性而创建的，通过良好的分层架构让开发人员能够专注于业务逻辑的开发。 Spring框架是一个分层架构，由不同的模块组成，构成spring的每个组件或模块都可以单独使用或者多个模块配合使用，以实现不同的功能需求。Spring框架的模块结构如下图所示： SpringCore是Spring框架的核心模块，提供s...
SpringCloud配置中心
Cat_Jay_Fish的博客
02-18 1231
一、SpringCloud Config 微服务意味着要将单体应用中的业务拆分成一个个子服务 , 每个服务的粒度相对较小 , 因此系统中会出现大量的服务。 由于每个服务都需要必要的配置信息才能运行 , 所以一套集中式的 , 动态的配置管理设施是必不可少的。 Spring Cloud 提供了 ConfigServer 来解决这个问题 . Spring Cloud Config 为微服务架构中的微服务提供集中化的外部配置支持 , 配置服务器为各个不同微服务应用的所有环境提供了一个中心化的外部配置。 Sp
spring cloud 2.0 config 配置中心，连接注册中心，@RefreshScope
06-11 4084
spring-boot版本：2.x 一、配置中心 配置中心支持从git，svn，本地获取配置文件，本文使用gitlab，（之后补充从本地获取） 1、配置文件项目 此项目下是配置文件，上传到gitlab upfs-provider和upfs-service对应项目名称，config client端配置的name，spring.application.name dev：开发环境 pr...
Spring入门：Bean IoC原理与常用配置详解
Spring框架是Java企业级应用开发中最常用的轻量级开源IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）容器。在Spring总结文档中，我们主要探讨了以下几个核心知识点： 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值