小黑子—spring：第二章 注解开发

二 小黑子的spring注解开发

1. Bean的基本注解开发

1.1 注解版本

Spring除了xml配置文件进行配置之外，还可以使用注解方式进行配置，注解方式慢慢成为xml配置的替代方案。我们有了xml开发的经验，学习注解开发就方便了许多，注解开发更加快捷方便。

Spring提供的注解有三个版本:

• 2.0时代，Spring开始出现注解

• 2.5时代，Spring的Bean配置可以使用注解完成

• 3.0时代，Spring其他配置也可以使用注解完成，我们进入全注解时代

• 基本Bean注解，主要是使用注解的方式替代原有xml的标签及其标签属性的配置

  <bean id="" name="" class="" scope="" lazy-init="" init-method="" destroy-method=""abstract="" autowire="" factory-bean="" factory-method="">bean>
  1

使用@Component注解替代标签

例：

@Component("userDao")
public class UserDaoImpl implements UserDao {
}
1
2
3

@Component("userService")
public class UserServiceImpl implements UserService {

}
1
2
3
4

<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 https://www.springframework.org/schema/context/spring-context.xsd">


    <context:component-scan base-package="com.itheima">context:component-scan>
beans>
1
2
3
4
5
6
7
8
9

• 测试

public class SpringTest {
    @Test
    public void springTest1(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object userDao = applicationContext.getBean("userDao");
        Object userService = applicationContext.getBean("userService");
        System.out.println(userService);
        System.out.println(userDao);
    }
}
1
2
3
4
5
6
7
8
9
10

1.2 @Component使用和作用范围

• 如果@Component不设置name属性，那会回自动将首字母小写的类名转化成name

使用@Component注解替代标签

1.2.1 作用范围等注解使用

package com.itheima.dao.impl;

import com.itheima.dao.UserDao;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

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

@Component("userDao")
@Scope("singleton")
@Lazy(false)
public class UserDaoImpl implements UserDao {
    public UserDaoImpl(){
        System.out.println("userDao创建。。。。");
    }

    @PostConstruct
    public void init(){
        System.out.println("userDao的初始话方法。。。");
    }

    @PreDestroy
    public void destory(){
        System.out.println("userDao的销毁方法。。。");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

@PostConstruct和 @PreDestroy注解报错的话，应该是缺少下面的依赖包：

        <dependency>
            <groupId>javax.annotationgroupId>
            <artifactId>jsr250-apiartifactId>
            <version>1.0version>
        dependency>
1
2
3
4
5

• 测试

    @Test
    public void springTest1(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object userDao = applicationContext.getBean("userDao");
        Object userService = applicationContext.getBean("userService");
        System.out.println(userService);
        System.out.println(userDao);
        applicationContext.close();
    }
1
2
3
4
5
6
7
8
9

1.2.2 @Component的三个衍生注解

由于JavaEE开发是分层的，为了每层Bean标识的注解语义化更加明确
@Component又衍生出如下三个注解:

@Service("userService")
public class UserServiceImpl implements UserService{}

@Repository("userDao")
public class UserDaoImpl implements UserDao{}

@Controller("userService")
public class UserController{}
1
2
3
4
5
6
7
8

2. Bean依赖注入注解开发

2.1 依赖注入相关注解

注入之后的形参，即使没有传值也是能够打印出来的

Bean依赖注入的注解，主要是使用注解的方式替代xml的标签完成属性的注入操作

<bean id=" "class="">
	<property name="" value=""/>
	<property name="" ref=""/>
bean>
1
2
3
4

Spring主要提供如下注解，用于在Bean内部进行属性注入的:

• @Value一般会引用Spring容器里面的一些值，根据key进行获取
• @Autowired根据类型进行注入，如果同一类型的Bean有多个，尝试根据名字进行二次匹配，如果匹配不成功则会报错
• 配合使用@Qualifier注解，可以在同一类型的多个Bean中根据名称注入相应的Bean
• @Resource不指定名称参数时，根据类型注入，指定名称则根据名称注入

@Service("userService")
public class UserServiceImpl implements UserService{

    @Value("zhangsan")
    private String username;
    
    //@Autowired //如果同一类型的Bean有多个，尝试根据名字进行二次匹配，如果匹配不成功则会报错
    //@Qualifier("userDao2") //配合使用@Autowired注解，可以在同一类型的多个Bean中根据名称注入相应的Bean
    @Resource //不指定名称参数时，根据类型注入，指定名称则根据名称注入
    private UserDao userDao;
    @Override
    public void show() {
        System.out.println(username);
        System.out.println(userDao);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.2 @Autowired扩展

• @Autowired使用该注解时，所查看的是参数的类型，跟方法的名称无关

@Service("userService")
public class UserServiceImpl implements UserService{
    @Autowired 
    public void xxx(UserDao userDao) {
        System.out.println("xxx:"+userDao);
    }
}

1
2
3
4
5
6
7
8

• 该注解同样可以获取一个集合,可以将同一类型的多个Bean打印出来

@Service("userService")
public class UserServiceImpl implements UserService{
    @Autowired 
    public void yyy(List<UserDao> userDaoList) {
        System.out.println("yyy:"+userDaoList);
    }
}

1
2
3
4
5
6
7
8

3. 非自定义Bean注解开发（管理第三方bean）

非自定义Bean不能像自定义Bean一样使用@Component进行管理，非自定义Bean要通过工厂的方式进行实例化，使用@Bean标注方法即可，@Bean的属性为beanName，如不指定为当前工厂方法名称

//将方法返回值Bean实例以@Bean注解指定的名称存储到spring容器中
//1.定义一个方法获得要管理的对象
//2.添加@Bean，表示当前方法的返回值是一个bean
@Bean ("datasource")
public DataSource dataSource (){
	DruidDataSource dataSource = new DruidDataSource();
	dataSource.setDriverClassName("com.mysql.jdbc.Driver");
	dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");
	dataSource.setUsername("root");
	dataSource.setPassword("123456");
	return dataSource;
}
1
2
3
4
5
6
7
8
9
10
11
12

• @Bean标注后面不加name值，则将类名赋值为name属性值

在参数中注入

@Component
public class otherBean {
    @Bean("dataSource")
    public DataSource dataSource(
   		@Value("${jdbc.driver}") String driver
   		@Qualifier("userDao") UserDao UserDao//不需要写@Autowired
	){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        return dataSource;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

如果@Bean工厂方法需要参数的话，则有如下几种注入方式：

• 使用@Autowired根据类型进行自动Bean的匹配，@Autowired可以省略
• 使用@Qualifier 根据名称进行Bean的匹配
• 使用@Value根据名称进行普通数据类型匹配
  

4. Bean配置类的纯注解开发

• 用了纯注解开发后，原来的配置文件换成了读配置类的形象加载
  

@Component等注解替代了标签，但是像、等非标签怎样去使用注解替代呢?

    
    
    <context:property-placeholder location="classpath:jdbc.properties">context:property-placeholder>
    <context:component-scan base-package="com.itheima">context:component-scan>
1
2
3
4

定义一个配置类替代原有的xml配置文件，标签以外的标签，一般都是在配置类上使用注解完成的

需要在配置类上加 @Configuration

作用：

1. 标识该类是一个配置类
2. 使其具备@Component作用

base-package的配置方式:

• 指定一个或多个包名:扫描指定包及其子包下使用注解的类
• 不配置包名:扫描当前@componentScan注解配置类所在包及其子包下的类

@Configuration //注解当前类是一个配置类（替代配置文件）+ @Component
//    
@ComponentScan("com.itheima")
// 
@PropertySource("classpath:jdbc.properties")
//
@Import(OtherBean.class)
public class SpringConfig {

}
1
2
3
4
5
6
7
8
9
10

例：

/@Component
public class OtherBean {

    @Bean("dataSource")
    public DataSource dataSource(
            @Value("${jdbc.driver}") String driverClassName,
            @Qualifier("userDao2")UserDao userDao,
            UserService userService
            ){
        DruidDataSource dataSource = new DruidDataSource();
        //设置4个参数

//        System.out.println(driverClassName);
//        System.out.println(userDao);

        return dataSource;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

    @Test
    public void springTest2(){
        //xml方式的Spring容器
        //ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注解方式去加载Spring的核心配置类
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        Object dataSource = applicationContext.getBean("dataSource");
        System.out.println(dataSource);
    }

1
2
3
4
5
6
7
8
9
10

5. Spring配置其他注解

配置其他注解

扩展:@Primary注解用于标注相同类型的Bean优先被使用权，@Primary 是Spring3.0引入的，与@Component和@Bean一起使用，标注该Bean的优先级更高，则在通过类型获取Bean或通过@Autowired根据类型进行注入时,会选用优先级更高的

@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Repository("userDao2")
@Primary
public class UserDaoImpl2 implements UserDao{}
1
2
3
4
5

@Bean("dataSource")
public DataSource dataSource(){}

@Bean("dataSource2")
@Primary
public DataSource dataSource2(){}
1
2
3
4
5
6

• 扩展：@Profile注解的作用同于xml配置时学习profile属性，是进行环境切换使用的

<beans profile="test">
1

注解@Profile标注在类或方法上，标注当前产生的Bean从属于哪个环境，只有激活了当前环境，被标注的Bean才能被注册到Spring容器里，不指定环境的Bean，任何环境下都能注册到Spring容器里

@Repository("userDao")
@Profile("test")
public class UserDaoImpl implements UserDao{}

@Repository("userDao2")
public class UserDaoImpl2 implements UserDao{}
1
2
3
4
5
6

测试
1.

@Test
    public void springTest2(){
        //xml方式的Spring容器
        //ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注解方式去加载Spring的核心配置类
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        Object userDao = applicationContext.getBean("userDao");
        System.out.println(userDao);
    }
1
2
3
4
5
6
7
8
9

2.

   @Test
    public void springTest2(){
        //xml方式的Spring容器
        //ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注解方式去加载Spring的核心配置类
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        Object userDao2 = applicationContext.getBean("userDao2");
        System.out.println(userDao2);
    }
1
2
3
4
5
6
7
8
9

可以使用以下两种方式指定被激活的环境：

• 使用命令行动态参数，虚拟机参数位置加载 -Dspring.profiles.active=test
• 使用代码的方式设置环境白能量System.setProperty("spring.profiles.active","test");

6. Spring注解的解析原理

结论：只要将Bean对应的BeanDefinition注册到beanDefinitionMap中，就可以经历整个SpringBean的生命周期，最终实例化进入单例池中

使用@Component等注解配置完毕后，要配置组件扫描才能使注解生效

• xml配置组件扫描：

<context:component-scan base-package="com.itheima"/>
1

• 配置类配置组件扫描：

@Configuration
@ComponentScan("com.itheima")
public class AppConfig {
}
1
2
3
4

注解的解析原理详解

7. Spring注解方式整合第三方框架

7.1 注解方式整合Mybatis代码实现

第三方框架整合，依然使用MyBatis作为整合对象，之前我们已经使用xml方式整合了MyBatis，现在使用注解方式无非就是将xml标签替换为注解，将xml配置文件替换为配置类而已，原有xml方式整合配置如下:
使用注解方式：

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver">property>
    <property name="url" value="jdbc:mysql://localhost:3306/mybatis">property>
    <property name="username" value="root">property>
    <property name="password" value="root">property>
bean>

<bean class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource">property>
bean>

<bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.itheima.mapper">property>
bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注解方式，Spring整合MyBatis的原理，关键在于@MapperScan，@MapperScan不是Spring提供的注解，是MyBatis为了整合Spring，在整合包org.mybatis.spring.annotation中提供的注解，源码如下:

@Configuration //注解当前类是一个配置类（替代配置文件）+ @Component
//    
@ComponentScan("com.itheima")
// 
@PropertySource("classpath:jdbc.properties")
//
@Import(OtherBean.class)
//Mapper的接口扫描
@MapperScan("com.itheima.mapper")
public class SpringConfig {

    @Bean
    public DataSource dataSource(
            @Value("${jdbc.driver}") String driver,
            @Value("${jdbc.url}") String url,
            @Value("${jdbc.username}") String username,
            @Value("${jdbc.password}") String password
    ){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

重点关注一下@lmport({MapperScannerRegistrar.class)，当@MapperScan被扫描加载时，会解析@Import注解，从而加载指定的类，此处就是加载了MapperScannerRegistrar

实现：

@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired //根据类型进行注入，如果同一类型的Bean有多给，会再尝试根据名字进行二次匹配，匹配不成功的会报错
//    @Qualifier("userDao2") //在此，结合@Autowired一起使用，作用是根据名称注入相应的Bean
//    @Resource(name="userDao2") //不指定名称参数时，根据类型注入，指定名称就根据名称注入
//    private UserDao userDao;
    private UserMapper userMapper;

    @Override
    public void show() {
//        System.out.println(userDao);
        List<User> all = userMapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 测试

   @Test
    public void springTest2(){
//        System.setProperty("spring.profiles.active","test");
        //xml方式的Spring容器
        //ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注解方式去加载Spring的核心配置类
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
//        Object userDao = applicationContext.getBean("userDao");
        UserService userService = applicationContext.getBean(UserService.class);
        userService.show();

    }
1
2
3
4
5
6
7
8
9
10
11
12

注解方式整合Mybatis原理

7.2 @Import整合第三方框架原理

Spring与MyBatis注解方式整合有个重要的技术点就是@Import，第三方框架与Spring整合xml方式很多是凭借自定义标签完成的，而第三方框架与Spring整合注解方式很多是靠@Import注解完成的。

@lmport可以导入如下三种类:

• 普通的配置类
• 实现lmportSelector接口的类

public class MyImportSelector implements ImportSelector { @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
    //参数annotationMetadata叫做注解媒体数组，该对象内部封装是当前使用了@Import注解上的类上的其他注解
    Map<String, Object> annotationAttributes = annotationMetadata.getAnnotationAttributes(ComponentScan.class.getName());
//    annotationAttributes.forEach((attrName,attrValue)->{
//        System.out.println(attrName+"=="+attrValue);
//    });
    String[] basePackages = (String[]) annotationAttributes.get("basePackages");
    System.out.println(basePackages[0]);

    // 返回的数组封装是需要被注册到Spring容器中的Bean的全限定名
        return new String[]{OtherBean2.class.getName()};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Configuration //注解当前类是一个配置类（替代配置文件）+ @Component
//    
@ComponentScan("com.itheima")
// 
@PropertySource("classpath:jdbc.properties")
//
//@Import(OtherBean.class)
//只能留一个@Import
@Import(MyImportSelector.class)
//Mapper的接口扫描
@MapperScan("com.itheima.mapper")
public class SpringConfig {

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试

@Test
    public void springTest3(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        OtherBean2 bean = applicationContext.getBean(OtherBean2.class);
        System.out.println(bean);
    }
1
2
3
4
5
6

• 实现lmportBeanDefinitionRegistrar接口的类

package com.itheima.beans;

public class OtherBean2 {
}
1
2
3
4

package com.itheima.anno;


import com.itheima.imports.MyImportBeanDefinitionRegistrar;
import org.springframework.context.annotation.Import;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportBeanDefinitionRegistrar.class)
public @interface MyMapperScan {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package com.itheima.imports;

import com.itheima.beans.OtherBean2;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        //注册BeanDefinition
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
        rootBeanDefinition.setBeanClassName(OtherBean2.class.getName());
        registry.registerBeanDefinition("OtherBean2",rootBeanDefinition);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 测试照旧
  

7.3 spring整合junit

导包：

<dependency>
	<groupId>org.springframeworkgroupId>
	<artifactId>spring-testartifactId>
	<version>5.2.10.RELEASEversion>
dependency>
1
2
3
4
5

整合junit

• @Runwith(SpringJUnit4ClassRunner.class)
• @ContextConfiguration(classes = 你所配置的环境)

使用Spring整合Junit专用的类加载器：
要测试谁，就在这个地方配置成一个属性装配进去就行了

8. 注解开发总结