SpringBoot入门到精通-Spring的注解编程
Posted 墨家巨子@俏如来
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot入门到精通-Spring的注解编程相关的知识，希望对你有一定的参考价值。
SpringBoot入门到精通系列
- SpringBoot入门到精通-Spring的注解编程(一)
- SpringBoot入门到精通-SpringBoot入门(二)
- SpringBoot入门到精通-Spring的基本使用(三)
- SpringBoot入门到精通-SpringBoot集成SSM(四)
前言
SpringBoot并不是一个新技术了，但是我发现很多程序员对SpringBoot的掌握并不成体系，或者说并不深入，看到该篇文章的你可能已经使用过SpringBoot了，但是你对SpirngBoot又了解多少呢，只是简单的使用还是有深入的认识。该系列文章将从零开始，一步一步由浅入深带你掌握好SpringBoot，同时又不失深度。
一.SpringBoot基础概念
1.什么是SpringBoot
在SpringBoot问世以前的传统项目架构大多都会使用Spring作为业务层技术框架,通常采用XML作为Spring的配置文件，在XML配置文件中我们为了整合持久层框架，WEB层框架以及其他三方框架需要配置一大堆内容，大量的配置内容显得非常的繁杂，降低了程序员的工作效率。
在Spring 3.0增加了注解编程(Java Config)来简化XML配置，并且Spring框架本身也大量使用到注解的方式进行配置，在2013年，Pivotal团队开始研发基于JavaConfig配置的SpringBoot框架，设计目的是用阿里简化新Spring应用的搭建及开发，2014年4月，发布全新开源的轻量级框架的第一个SpringBoot版本。
到底什么是SpringBoot
以下内容摘抄于百度百科
Spring Boot是其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。
从百度百科的解释中我们可以总结出SpringBoot的设计初衷，首先SpringBoot肯定是基于Spring进行封装的，底层还是Spirng，它的设计目的是用来简化传统Spring应用的搭建和开发过程，有自己的特定配置方式。那么这个特定的配置方式指的是什么呢？就是上面有提到的Java Config。
所以简单理解：SpringBoot是基于Spring的注解进行配置(JavaConfig)，设计目的是简化Spring的开发。
2.什么是JavaConfig
上面我们有提到一个概念Java Config 那么到底什么是Java Config, 我们可以这样理解：Java可以认为是Java类，Config指的是配置，那么Java Config就是使用Java类作为Spring的配置文件，更直白一点就是把以前的XML配置文件中的内容全都搬到Java类进行配置。
同时Java Config也叫Spring的注解编程，因为在Spring的配置类中会大量使用到注解。
二.SpringBoot注解编程
1.Spring的IOC案例
什么是IOC？ 控制反转，就是把对象的创建，属性设置，初始化，销毁(Bean的生命周期)等工作都交给Spring来管理，实例化好的Bean会注入到Spring容器中，使用的时候直接从容器中获取，从而解放程序员的劳动力。那接下来我们先以XML配置方式来回顾一下Spring的IOC的用法，然后再使用注解编程方式(Java Config 也叫 Spring的注解编程)方式来演示IOC案例。
1.1.基于XML的IOC
第一步：首先我们需要创建一个普通的Java项目，然后导入Spring的基础依赖，使用 spring-context就可以了,为了方便测再导入一个 spring-test依赖
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.3.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.0.RELEASE</version>
</dependency>
</dependencies>
第二步：接着我们在resource目录创建一个xml作为Spring配置文件,内容如下
<?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 id="user" class="cn.whale._01_xml_ioc.Student">
<property name="id" value="1"/>
<property name="username" value="zs" />
</bean>
</beans>
第三步：编写实体类 Student
public class Student
private Long id;
private String username;
public Student()
public Student(Long id, String username)
this.id = id;
this.username = username;
public Long getId()
return id;
public void setId(Long id)
this.id = id;
public String getUsername()
return username;
public void setUsername(String username)
this.username = username;
@Override
public String toString()
return "Student" +
"id=" + id +
", username='" + username + '\\'' +
'';
第四步 : 编写测试类
//XML版本 IOC测试
public class StudentTest
@Test
public void test()
//创建IOC容器工厂类 ， 加载配置 ， 得到容器对象
ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
//从容器中获取Bean
Student bean = applicationContext.getBean(Student.class);
//打印
System.out.println(bean);
这里使用了一个 ClassPathXmlApplicationContext 来加载Spring的配置文件。ClassPathXmlApplicationContext 是IOC容器工厂类，可以默认从classpath加载指定配置。
根据上面案例我们可以总结出IOC的步骤：
- 首先需要有个xml配置文件，配置好Student
- 然后需要有个IOC工厂类去加载xml配置，Spring会自动把xml中配置的Bean注册到容器中
- 最后从容器中直接获取到Bean即可
1.2.基于Java Config的IOC
第一步：创建一个配置类作为Spring的配置文件，用来代替xml配置文件，同时贴上@Configuration标记该类为Spring的配置类
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
public class JavaConfig
第二步：在配置类中注册Bean
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
public class JavaConfig
//注册一个Student到Spring容器中
@Bean
public Student student()
return new Student();
@Bean贴在方法上，该方法的返回值会自动注册到Spring容器中。
第三步：编写测试类,使用 AnnotationConfigApplicationContext 来加载配置类
//XML版本 IOC测试
public class StudentTest
@Test
public void test()
//创建IOC容器工厂类 ， 加载配置 ， 得到容器对象
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(JavaConfig.class);
//从容器中获取Bean
Student bean = applicationContext.getBean(Student.class);
//打印
System.out.println(bean);
ClassPathXmlApplicationContext是针对xml的容器工厂，而AnnotationConfigApplicationContext是针对配置类的容器工厂。
总结一下：
- @Configuration ： Spring的配置注解，标记某个类成为Spring配置类
- @Bean ：用来在配置类中，注册Bean的注解，贴方法上方法的返回实例会被识别为Spring的Bean交给Spring管理
- AnnotationConfigApplicationContext ：是针对配置类的容器工厂，SpringBoot中使用的也是这个工厂
2.@Bean的详解
2.1.Bean的属性
下面我们来介绍一下@Bean来做一个全方位的认识，下面是它的结构
@Target(ElementType.METHOD, ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean
//Bean的名称，如果未指定就使用方法名作为Bean的名称
String[] name() default ;
//自动装配
Autowire autowire() default Autowire.NO;
//Bean的初始方法
String initMethod() default "";
//Bean的销毁方法
String destroyMethod() default "(inferred)";
这里稍作解释
- name : Bean的名称，如果未指定就使用方法名作为Bean的名称
- autowire ：依赖项是否通过基于约定的自动装配按名称或类型注入
- initMethod ： 初始化方法
- destroyMethod ： 销毁方法
2.2.Bean的生命周期
根据上面的解释我们给之前的代码做些改造
//注册一个Student到Spring容器中
@Bean(name = "student" , //bean的名字
initMethod = "init", //初始化方法，需要给Student提供init方法
destroyMethod = "destory") //销毁方法，需要给Student提供destory方法
public Student student()
return new Student(1L,"zs");
然后给Student提供两个方法 , 将我们再次执行测试，就可以看到init方法被执行。
public class Student
//省略...
public void init()
System.out.println("Bean的init被执行...");
public void destory()
System.out.println("Bean的destory被执行...");
注意：destory方法并不会被执行，因为我们使用的是Junit的测试，如果想要destory正常执行，需要使用Spring-Test。
2.3.destory不执行问题
Bean的Destory方法没被执行的原因是Spring容器没被正常关闭，因为我们使用的Junit的测试，测试类是没有交给Spring管理的，当测试方法执行完毕，整个程序也就终止，Spring容器没办法正常关闭，解决方案有两个：一是使用JDK1.7的自动关闭资源的新特性；二是使用Spring的测试，把测试类也交给Spring容器管理。
方式一：使用JDK1.7的自动关闭资源的新特性
//IOC测试
public class StudentTestBF
@Test
public void test()
try(
//创建IOC容器工厂类 ， 加载配置 ， 得到容器对象
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(JavaConfig.class)
)
//从容器中获取Bean
Student bean = applicationContext.getBean(Student.class);
//打印
System.out.println(bean);
测试效果如下
方式二：整合Spring的测试，使用@RunWith+@ContextConfiguration注解来完成，要注意的是现在的配置文件是一个配置类，需要通过ContextConfiguration的classes属性来指定。如下：
//IOC测试
@RunWith(SpringJUnit4ClassRunner.class)
//
@ContextConfiguration(classes = JavaConfig.class)
public class StudentTest
//不再需要创建AnnotationConfigApplicationContext，直接注入即可
//@Autowired
//private ApplicationContext applicationContext;
@Autowired
private Student student;
@Test
public void test()
//从容器中获取Bean
//Student student = applicationContext.getBean(Student.class);
//打印
System.out.println(student);
集成Spring的测试之后，我们可以通过注入 ApplicationContext 容器来获取Bean, 甚至直接注入需要的Bean,效果如下
这里我再介绍一种实现Spring的Bean的生命周期的方式，就是 通过@PostConstract+@PreDestory注解来完成，如下
public class Student
...省略...
//PostConstruct : 该注解用于需要在依赖注入完成后执行任何初始化的方法
@PostConstruct
public void init2()
//PreDestroy : 注释在方法上用作回调通知，以表明实例正在被容器移除
@PreDestroy
public void destory2()
这里解释一下这2个注解
- @PostConstruct ：标记了该注解的方法会在：对象的依赖注入完成后执行，可以用作对象的初始化
- @PreDestroy ：当Spring容器移除该对象之前会触发标记了该注解的方法的调用，可以用来做一些扫尾工作
这里我介绍了2种生命周期方法，根据你自己的情况使用其中一种就行，当然还有其他的手段，比如通过实现 InitializingBean 和 DisposableBean 来完成，你可以自己去了解一下，这不是我们今天的重点。
2.3.Bean的Scope
Spring中的Bean默认情况下scope为singleton , 在Spring注解编程中提供了@Scope注解来指定，如下
//注册一个Student到Spring容器中
@Bean
@Scope("singleton") //单利，指定为 ： prototype 就是多利
public Student student()
return new Student(1L,"zs");
如果没有特殊的需求不建议去修改该属性，默认单利就好。
2.4.Bean的懒初始化
在Spring中Bean默认是lazy=false , 在Spring启动的时候，会对 scope为singleton也就是单利的Bean，且没有配置lazy = true的普通Bean进行实例化。也就是说一个普通的Bean在Spring启动的过程中就会为该Bean进行实例化，然后把实例化后的Bean存储到单利Bean的容器中(一个ConcurrentHashMap中)。
在Spring的注解式编程中提供了@Lazy注解来修改是否要懒初始化,如下
@Bean
@Lazy(true) //懒初始化，使用到Bean的时候才会初始化
public Student student()
return new Student(1L,"zs");
当然没有特殊情况此注解也不建议去加，默认就是迫切初始化的。
3.Bean的依赖入驻
bean的依赖注入就是DI，我们的Bean交个了Spring去管理，那么Bean和Bean之间的依赖关系也需要Spring为我们去维护，这个就是Spring的属性注入(也叫依赖注入)，即DI。在注解式编程中，注册Bean的方式不同，DI的方式也不同。
3.1.准备对象
我们先来创建2个类，然后处理好依赖关系
第一步：创建一个Teacer类
public class Teacher
第二步：创建Student类，它依赖了一个Teacher,同时我这里提供了一个构造器方便注入值
public class Student
private Long id;
private String username;
//依赖teacher
private Teacher teacher;
public Student(Long id, String username, Teacher teacher)
this.id = id;
this.username = username;
this.teacher = teacher;
...省略...
3.2.配置Bean的依赖关系
方式一：我们需要定义两个Bean,Teacher和Student ,然后还要为 Student中的Teacher属性注入值(DI)
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
public class JavaConfig
//注册一个Student到Spring容器中
@Bean
public Student student()
//直接new 一个Teacher对象交给Student.
return new Student(1L,"zs",new Teacher());
上面我直接new了一个Teacher,交给Student。这种方式确实注入了一个Teacher给Stduent，但是Teacher本身本没有交个Spring管理。
方式二：通过调用Teancher的Bean的定义方法。如果要把Teacher交给Spring管理，那么就必须要定义Teacher的Bean。
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
public class JavaConfig
//注册一个Student到Spring容器中
@Bean
public Student student()
return new Student(1L,"zs",teacher());
//注册一个Teacher到Spring容器中
@Bean
public Teacher teacher()
return new Teacher();
上面是把Teacher和Student都注册成为Bean,交给Spring管理，然后Student中的Teacher依赖是通过调用teacher()方法来注入，注意：这种调方法的方式也是从容器中拿Bean的。但是这种方式的弊端是两个Bean的定义方法必须在同一个配置类
方式三：通过方法传入依赖对象
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
public class JavaConfig
//注册一个Student到Spring容器中
@Bean
public Student student(Teacher teacher)
return new Student(1L,"zs",teacher);
//注册一个Teacher到Spring容器中
@Bean
public Teacher teacher()
return new Teacher();
上面代码对于Student的定义方法是传入了一个Teacher类注入给Student,这种方式Spring会自动从容器中找到Teacher，然后赋值给student方法的形参teacher，然后完成注入。这种方式的好处是如果依赖的Bean(比如这里的Teacher)不在当前配置类也可以注入。
4.@ComponentScan的使用
4.1.认识ComponentScan
在之前的案例中我们是通过@Bean贴方法上的方式来注册Bean，这本身也没有什么问题，但是当我的Bean特别多的时候，那么我们就需要写很多的方法非常的麻烦。在XML的配置方式中我们也是可以通过<context:component-scan base-package/>指定一个扫描包 的方式来开启IOC组件自动扫描，然后我们只需要在需要交给Spring管理的类上贴：@Controller ,@Service,@Component,@Repository 等注解即可，当Spring启动的时候，就会自动去扫描指定的base-package包下的标记了如上注解的类，自动注入到Spring容器中。
在注解式编程中Spring也提供了一个注解@ComponentScan 来达到如上所述的相同效果。下面演示一下
第一步：对实体类进行改造，增加一个@Component 注解
//标记为Spring的组件
//@Controller
//@Service
//@Repository
@Component
public class Student
private Long id;
private String username;
...省略...
第二步：配置类增加@ComponentScan
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
//Spring的IOC自动扫描，可以自动多个扫描包
@ComponentScan(basePackages = "cn.whale._03_ioc_scan")
public class JavaConfig
重点说一下 @ComponentScan注解，上面给该注解指定了一个basePackages扫描包路径，那么该注解就会扫描到该表下的贴了@Controller ,@Service,@Component,@Repository 的类，自动完成Bean的注解。如果没有指定basePackages该注解也会默认扫描当前包及其子包中的相关类。
需要注意：如果使用了IOC自动扫描的方式，就可以不使用@Bean的方式注册Bean了，切记。
第三步：执行测试代码，效果同上面案例，这里省略.
4.2.ComponentScan的属性
ComponentScan提供了一些属性供我们使用，如下
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan
//配置扫描的包路径
@AliasFor("basePackages")
String[] value() default ;
//配置扫描的包路径
@AliasFor("value")
String[] basePackages() default ;
//包含的资源过滤器
Filter[] includeFilters() default ;
//排除的资源过滤器
Filter[] excludeFilters() default ;
//指定是否延迟初始化Bean。默认迫切初始化
boolean lazyInit() default false;
4.3.排除资源excludeFilters
该注解中还提供了 lazyInit 来指定是否要懒初始化，还提供了 excludeFilters 来排除某些类不需要交给Spring管理，比如我同一个包下有Student和Teacher类都注解了@Component，但是我想排除Teacher不交给Spring管理，如下：
@Component
public class Student
@Component
public class Teacher
配置类通过excludeFilters来排除，如下
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
//Spring的IOC自动扫描
@ComponentScan(basePackages = "cn.whale._03_ioc_scan",
//根据类型，排除Teacher这个类不要交给Spring管理
excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE , value = Teacher.class)
)
public class JavaConfig
type = FilterType.ASSIGNABLE_TYPE ： 是通过类型来排除，也可以支持通过注解来排除，通过REGEX正则来排除等。
4.4.ComponentScans
ComponentScans是ComponentScan的复数形式，可以把多个ComponentScan进行组合，如下
//Spring配置注解，标记该类是Spring的配置类，该类的作用等同于applicationContext.xml
@Configuration
@ComponentScans(
@ComponentScan(basePackages = "cn.whale._03_ioc_scan",
//根据类型，排除Teacher这个类不要交给Spring管理
excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE , value = Teacher.class)
),
@ComponentScan(basePackages = "cn.whale._04_ioc_scan",
//根据类型，排除Teacher这个类不要交给Spring管理
excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE , value = Teacher.class)
),
)
public class JavaConfig
这种用法比较复杂，更多的还是使用 @ComponentScan 就能满足我们的需求了。
4.5.Bean的依赖关系
前面们在讲DI的时候，是使用定义方法的方式来注册Bean,而现在我们使用组件自动扫描，
以上是关于SpringBoot入门到精通-Spring的注解编程的主要内容，如果未能解决你的问题，请参考以下文章
SpringBoot入门到精通-SpringBoot启动流程
SpringBoot入门到精通-SpringBoot自动配置原理
SpringBoot入门到精通-SpringBoot自定义starter