新建一个springboot工程,仅仅需要引入2个jar包就可以操作使用redis
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-redisartifactId>
dependency>
@RestController
public class SpringRedisTestController {
@Autowired
RedisTemplate redisTemplate;
@RequestMapping("/getRedisValue")
public String getRedisValue() {
//赋值
String key = "spring:redis:test";
redisTemplate.opsForValue().set(key,"testvalue",10,TimeUnit.SECONDS);
// 取值
String val = (String)redisTemplate.opsForValue().get(key);
System.out.println("从redis中取值===》 " + val);
return val;
}
}
@SpringBootApplication
public class ApplicationStart {
public static void main(String[] args){
SpringApplication.run(ApplicationStart.class,args);
}
}
访问http://localhost:8080/getRedisValue,执行结果如下
就这么简单的就可以使用redis,不需要写任何xml配置文件,也不需要写任何config配置类,只需要引入redis的jar包就可以使用redis,
为什么springboot将redis的使用变的这么简单?基本上啥都没干,就写了地址,就可以使用redis了?
首先我们要思考的是,既然我们没有写配置类,那么redis的配置文件是如何加载的呢?RedisTemplate又是如何加载的呢?
这就要依赖于springboot的核心特性,自动装配机制。下面进行解析
从上面代码看下来,整个启动过程我们只用了一个注解,那就是@SpringBootApplication,点进去可以发现新大陆。
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
...
}
@ComponentScan是扫描包路径的,默认扫描的是启动类所在的包路径,以及子包下面的Bean
@SpringBootConfiguration这个点进去看,也很简答,仅仅是对spring本身的configuration的封装
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
@EnableAutoConfiguration 这个注解就是自动装配的核心
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}
从这个注解上,可以看到引用了一个重要的ImportSelector即 AutoConfigurationImportSelector.class
如果不是很明白importSelector,建议先了解下,因为这个的作用就是动态注册Bean,注入各种Configuration的核心,在springboot中很重要。建议一定要了解
在AutoConfigurationImportSelector中,通过selectImports 方法进行动态注册Bean,
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}
主要看getAutoConfigurationEntry 这个方法,大致看下这个方法主要做了几件事
#1 获取启动类上的注解属性信息
#2 获得指定路径下所需要加载的configuration
#3 条件加载,因为不是所有configuration都需要加载,所以需要过滤
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
} else {
// #1 获取启动类上的注解属性信息
AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
// #2 获得指定路径下所需要加载的configuration
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
// 去重
configurations = this.removeDuplicates(configurations);
// 查看哪些类不需要加载,这个和#1有关,一般是用@SpringBootApplication(exclude = XXX.class)配置
Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
this.checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
// #3 条件加载,因为不是所有configuration都需要加载,所以需要过滤
configurations = this.getConfigurationClassFilter().filter(configurations);
this.fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
}
}
最核心的是#2和#3这两步
根据上面代码进入#2这一步getCandidateConfigurations,最后可以看到加载的位置
加载了这些文件后,就会加载默认配置的那些Configuration,比如会自动加载RedisAutoConfiguration
继续用redis举例子,进入RedisAutoConfiguration
可以看到类上有这些注解
@Configuration(
proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class}) // 这个是条件加载,当RedisOperations存在才会加载
@EnableConfigurationProperties({RedisProperties.class}) // 这个很关键,这里是加载redis的配置信息
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})// 这里会加载一个reidis工厂类LettuceConnectionFactory
public class RedisAutoConfiguration {
public RedisAutoConfiguration() {
}
@Bean
@ConditionalOnMissingBean(
name = {"redisTemplate"}
)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
RedisTemplate<Object, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
到这里一个RedisAutoConfiguration 就加载完成了,RedisTemplate也相继加载完成。
所以在我们的springboot工程中,即使没有写任何额外的xml配置或者redis配置类,只需要简单的属性配置(application.properties中),就可以使用redis,这个得益于springboot的自动装配机制,启动的时候,就会加载所有默认configuration,只要引用的相关的jar包就行,这里引入了redis的jar包,spring-boot-starter-data-redis,所以就会加载RedisAutoConfiguration ,如果不引用就不会加载。
我们也可以利用SPI机制自定义spring-boot第三方jar包,只需要再META-INF中定义好需要自动加载的configuration就行。比如自定义的jar中添加META-INF/spring.factories,内容如下
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.test.redission.MyRedissonAutoConfiguratio
这样就会自动加载MyRedissonAutoConfiguratio
再比如最近两年dubbo对spring-boot的集成也是同样道理,引入jar包dubbo-spring-boot-starter,就可以使用spring-boot方式配置dubbo。在dubbo-spring-boot-autoconfigure可以看到这个文件spring.factories