【Java从0到架构师】Spring - 注解

Dear 丶 2022-09-03 05:12 201阅读 0赞

### 注解 ###

*  读取多个配置文件
 *  注解实现 bean 标签 - @Component、@Component-scan
 *  注解实现注入 - @Autowired、@Value、@PropertySource
 *  注解实现 AOP
 *   *  复用切入点 - @Pointcut
 *  注解实现事务管理
 *  @Configuration、@Bean
 *   *  @Bean 方法的注入 - bean
     *  @Bean 方法的注入 - FactoryBean
     *  @Bean 方法的注入 - 其他类型
 *  创建工厂的入口
 *  bean 的创建方式总结

> Java 从 0 到架构师目录：[【Java从0到架构师】学习记录][Java_0]

> 学习 Spring 搭配这门课效果更好：[《孙哥说Spring5》学习笔记][Spring5]

Gitee 代码：[https://gitee.com/szluyu99/mj\_java\_frame/tree/master/02\_Spring/][https_gitee.com_szluyu99_mj_java_frame_tree_master_02_Spring]

> 关联文章：
> 
>  *  [Spring 基础注解（对象创建相关注解、注入相关注解、注解扫描详解）][Spring]
>  *  [Spring 高级注解（@Configuration、@Bean、@ComponentScan）][Spring _Configuration_Bean_ComponentScan]

# 读取多个配置文件 #

如果 Spring 配置文件过多，可以采取读多个配置文件的形式：

**方法 1**：Java 代码中传入多个配置文件进行读取

ApplicationContext ctx = new ClassPathXmlApplicationContext(
            "applicationContext.xml",
            "applicationContext-mybatis.xml",
            "applicationContext-tx.xml");

**方法 2**：在主配置文件中，导入其他配置文件

Java 代码中读取主配置文件

ApplicationContext ctx = new 
    				ClassPathXmlApplicationContext("applicationContext.xml");

**方法 3**：Java 代码中通过通配符读取多个配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext(
    				"classpath*:applicationContext*.xml");

> `classpath*:applicationContext*.xml` 的原理参考：
> 
>  *  PathMatchingResourcePatternResolver 的 getResources 方法

# 注解实现 bean 标签 - @Component、@Component-scan #

`@Component`：相当于 <bean> 标签

*  通过 value 属性设置 bean 的 id，默认会将类名的首字母小写形式作为 bean 的 id
 *  `@Controller` 用于标识控制器层，`@Service` 用于标识业务层，`@Repository` 用于标识 Dao 层

`@Scope`：设置 singleton、prototype

`@Lazy`：满足 `scope="singleton"` 时延迟加载

通过 <context:component-scan> 标签设置需要扫描的包，可以扫描到该包下所有的 `@Component`

<context:component-scan base-package="com.mj.service" />

`@ComponentScan`：相当于 <context:component-scan> 标签；[示例代码][Link 1]

# 注解实现注入 - @Autowired、@Value、@PropertySource #

`@Autowired`：默认按照类型注入 bean 实例

*  可以写在成员变量（不会调用 setter）、setter、构造方法上
 *  可以配合 `@Qualifier`、`@Named`：设置需要注入的 bean 的 id
 *  `required="false"`：找不到对应的 bean 时不会抛出异常
 *  [示例代码][Link 2]

`@Value`：用于注入 String、基本类型、BigDecimal 等类型

*  可以配合配置文件（比如 properties）使用 `${}` 读取配置文件的暖色内容
 *  [示例代码][Link 2]

`@PropertySources`、`@PropertySource`：相当于 [<context:property-placeholder>][context_property-placeholder]

*  [示例代码][Link 2]

--------------------

可以通过 `@Autowired` 指定创建 bean 时调用的构造方法：

public Student() { }
    
    // 创建bean时会调用这个构造方法
    @Autowired
    public Student(@Value("MJ666") String name,
    			   @Qualifier("dog") Dog dog) { 
    	this.name = name;
    	this.dog = dog;
    }

// @Nullable会注入null值
    @Autowired
    public Student(@Nullable String name,
    			   @Qualifier("dog") Dog dog) { 
    	this.name = name;
    	this.dog = dog;
    }

# 注解实现 AOP #

`@Aspect`：用来标识一个切面类（切面类对象需要被放到 IoC 容器中）

`@Around` ：用来设置切入点（被注解的方法要有返回值，接受一个 ProceedingJoinPoint 参数）

还需要加入 [<aop:aspectj-autoproxy>][aop_aspectj-autoproxy] 标签，替代之前的 <aop:config>

*  同样有 proxy-target-class 属性设置 AOP 的底层实现方案

<aop:aspectj-autoproxy proxy-target-class="true" />

[示例代码][Link 3]

## 复用切入点 - @Pointcut ##

可以使用 `@Pointcut` 复用切入点：[示例代码][Link 3]

@Aspect
    @Component
    public class DefaultAspect { 
        @Pointcut("within(com.mj.service.impl.UserServiceImpl)")
        public void pc() { }
    
        @Around("pc()")
        public Object log(ProceedingJoinPoint point) throws Throwable { 
            System.out.println("log-----------------------1");
            // 调用目标方法
            Object ret = point.proceed();
            System.out.println("log-----------------------2");
            return ret;
        }
    
        @Around("pc()")
        public Object watch(ProceedingJoinPoint point) throws Throwable { 
            System.out.println("watch-----------------------1");
            // 调用目标方法
            Object ret = point.proceed();
            System.out.println("watch-----------------------2");
            return ret;
        }
    }

在配置文件中也可以复用代码中通过注解定义的切入点：

<bean id="logInterceptor" class="com.mj.aop.LogInterceptor"/>
    
    <aop:config>
    	
        <aop:pointcut id="pc" expression="com.mj.aop.DefaultAspect.pc()"/>
        
        <aop:advisor advice-ref="logInterceptor" pointcut-ref="pc"/>
    </aop:config>
    ```上面的写法与下面等价：可以将定义切入点、组装切面写在一起
    >一般会将定义切入点与组装分开写
    ```xml
    <aop:config>
    	
    	<aop:advisor advice-ref="logInterceptor" pointcut="com.mj.aop.DefaultAspect.pc()"/>
    </aop:config>

# 注解实现事务管理 #

[注解事务管理代码][Link 4]

`@Transactional`：

*  可以在需要进行事务管理的**类**（比如 Service）上使用这个注解，代表所有方法都会自动管理事务
 *  可以在需要进行事务管理的**方法**上使用这个注解（可以覆盖类上 `@Transactional` 的配置）
 *  可以设置 isolation、propagation、timeout、rollbackFor、noRollbackFor、readOnly 等属性

使用 [<tx:annotation-driven>][tx_annotation-driven] 取代之前的 <tx:advice>、<aop:config>

<bean id="txMgr" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource"/>
    </bean>
    
    <tx:annotation-driven transaction-manager="txMgr"/>

# @Configuration、@Bean #

`@Configuration`：使用此注解的类，可以取代 applicationContext.xml

*  它本质上也是一个 `@Component`，所以可以通过 component-scan 扫描

可以在 `@Configuration` 类中，使用 `@Bean` 修饰方法，**进行 Bean 对象的创建**

*  默认情况下，方法名就是 bean 的 id；也可以通过 name、value 属性设置 bean 的 id
 *  可以配合 `@Scope` 设置 bean 的创建次数

@Configuration
    public class BeanConfig { 
    	@Bean("person")
    	@Scope("prototype")
    	public Person person() { 
    		return new Person();
    	}
    }

## @Bean 方法的注入 - bean ##

如果 bean 属性本身有 `@Autowired`，那么直接 new 原来对象即可；[示例代码][Link 5]

@Component
    public class Dog { 
    }

public class Person { 
    	private Dog dog;
    	@Autowired
    	public void setDog(Dog dog) { 
    		this.dog = dog;
    	}
    }

@Configuration
    public class BeanConfig { 
    	@Bean
    	public Person person() { 
    		return new Person();
    	}
    }

--------------------

**Spring 会利用 `@Autowired` 技术，自动注入 bean 给 `@Bean` 方法的参数**

@Bean
    public Person person(Dog dog) { 
    	Person person = new Person();
    	person.setDog(dog);
    	return person;
    }

--------------------

直接调用 `@Bean` 方法

@Bean
    public Dog dog() { 
    	return new Dog();
    }

@Bean
    public Person person() { 
    	Person person = new Person();
    	person.setDog(dog());
    	person.setDog(dog()); // 调用多次 dog(), 也可以保证是 singleton
    	person.setDog(dog());
    	return person;
    }

这里有个细节：`@Bean` 就算被直接调用多次，也能保证是 singleton

*  因为 `@Configuration` 底层使用了 CGLib 动态代理，对 `@Bean` 方法进行了增强处理

> 我们获取到的 `@Configuration` 注释的类的对象是代理对象，就算通过它去多次调用某个 dog()，它底层会做一些判断，例如：如果某个对象已经在 Ioc 容器中则直接返回该对象，因此可以保证 `@Bean` 是 singleton

## @Bean 方法的注入 - FactoryBean ##

[FactoryBean 示例][FactoryBean]

@Component
    public class DogFactoryBean implements FactoryBean<Dog> { 
        @Override
        public Dog getObject() throws Exception { 
            return new Dog();
        }
    
        @Override
        public Class<?> getObjectType() { 
            return Dog.class;
        }
    }

@Configuration
    public class BeanConfig { 
    	@Bean
    	public DogFactoryBean dog() { 
    		return new DogFactoryBean();
    	}
    }

// com.mj.domain.Dog@644baf4a
    System.out.println(ctx.getBean("dog"));

表面上看，`@Bean` 方法返回的是 DogFactoryBean

*  由于 `@Configuration` 底层使用的 CGLib
 *  对 `@Bean` 进行了增强处理
 *  会调用 DogFactoryBean 的 getObject 方法

## @Bean 方法的注入 - 其他类型 ##

@Configuration
    @PropertySource("person.properties")
    public class BeanConfig() { 
    	@Value("${age}]")
    	private int age;
    	@Value("${name}")
    	private String name;	
    	
    	@Bean
    	public Person person() { 
    		Person person = new Person();
    		person.setAge(age);
    		person.setName(name);
    		return person;
    	}
    }

# 创建工厂的入口 #

> 注解创建工厂的方法很多，主要考虑：
> 
>  *  这个类有没有被放到容器中
>  *  这个类有没有被扫描到

如果创建工厂的入口是 XML，一般使用 ClassPathXmlApplicationContext

*  可以通过 <context:component-scan> 去扫描注解信息
 *  可以通过 <import> 导入其他配置文件
    
        ctx = new ClassPathXmlApplicationContext("applicationContenxt.xml");

如果创建工厂的入口是**注解**，一般使用 [AnnotationConfigApplicationContext][]

*  可以通过 `@Import`、`@Component` 扫描其他注解信息
 *  可以通过 `@ImportSource` 导入其他 Xml 配置文件
    
        ctx = new AnnotationConfigApplicationContext("com.mj");
    
        ctx = new AnnotationConfigApplicationContext(Person.class);

注意：通过 `@Import` 导入创建的 bean 的 id 是全类名

# bean 的创建方式总结 #

在 Spring 中，bean 有 3 种常见的创建方式：

*  `@Component`：常用于源码可以修改，创建过程比较简单（直接调用构造方法即可）的类型
 *  `@Bean`：常用于源码不可以修改（比如第三方库的类型）或者创建过程比较复杂的类型
 *  <bean>：适用于所有类型

当上述三种方式 bean 的 id 相同时，优先级如下：

*  <bean> > `@Bean` > `@Component`

> <bean> 可以覆盖以前 `@Bean`、`@Component` 的内容，所以可以减少它们代码的变动

[Java_0]: https://blog.csdn.net/weixin_43734095/article/details/119067034
[Spring5]: https://blog.csdn.net/weixin_43734095/article/details/106309373
[https_gitee.com_szluyu99_mj_java_frame_tree_master_02_Spring]: https://gitee.com/szluyu99/mj_java_frame/tree/master/02_Spring/
[Spring]: https://blog.csdn.net/weixin_43734095/article/details/106579553
[Spring _Configuration_Bean_ComponentScan]: https://blog.csdn.net/weixin_43734095/article/details/115947808
[Link 1]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/20_Spring13_%E5%B8%B8%E8%A7%81%E6%B3%A8%E8%A7%A3/src/main/java/com/mj/domain/Person.java
[Link 2]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/20_Spring13_%E5%B8%B8%E8%A7%81%E6%B3%A8%E8%A7%A3/src/main/java/com/mj/domain/User.java
[context_property-placeholder]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/20_Spring13_%E5%B8%B8%E8%A7%81%E6%B3%A8%E8%A7%A3/src/main/resources/applicationContext.xml
[aop_aspectj-autoproxy]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/21_Spring14_%E6%B3%A8%E8%A7%A3AOP/src/main/resources/applicationContext.xml
[Link 3]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/21_Spring14_%E6%B3%A8%E8%A7%A3AOP/src/main/java/com/mj/aop/DefaultAspect.java
[Link 4]: https://gitee.com/szluyu99/mj_java_frame/tree/master/02_Spring/22_Spring15_%E6%B3%A8%E8%A7%A3%E4%BA%8B%E5%8A%A1%E7%AE%A1%E7%90%86
[tx_annotation-driven]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/22_Spring15_%E6%B3%A8%E8%A7%A3%E4%BA%8B%E5%8A%A1%E7%AE%A1%E7%90%86/src/main/resources/applicationContext.xml
[Link 5]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/23_Spring16_@Configuration_@Bean/src/main/java/com/mj/domain/Person.java
[FactoryBean]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/23_Spring16_@Configuration_@Bean/src/main/java/com/mj/bean/DogFactoryBean.java
[AnnotationConfigApplicationContext]: https://gitee.com/szluyu99/mj_java_frame/blob/master/02_Spring/24_Spring17_%E5%88%9B%E5%BB%BA%E5%B7%A5%E5%8E%82%E7%9A%84%E5%85%A5%E5%8F%A3/src/test/java/com/mj/SkillTest.java