第一章、注解基础概念

1. 什么是注解编程
  1. 指的是在类或者方法上加入特定的注解(@XXX),完成特定功能的开发。
  2. @Component
  3. public class XXX{}

2. 为什么要讲解注解编程
  1. 1. 注解开发方便
  2. 代码简洁 开发速度大大提高
  3. 2. Spring开发潮流
  4. Spring2.x引入注解 Spring3.x完善注解 SpringBoot普及 推广注解编程

3. 注解的作用
  • 替换XML这种配置形式,简化配置
    image.png
  • 替换接口,实现调用双方的契约性
    1. 通过注解的方式,在功能调用者和功能提供者之间达成约定,进而进行功能的调用。因为注解应用更为方便灵活,所以在现在的开发中,更推荐通过注解的形式,完成
    image.png

4. Spring注解的发展历程
  1. 1. Spring2.x开始支持注解编程 @Component @Service @Scope..
  2. 目的:提供的这些注解只是为了在某些情况下简化XML的配置,作为XML开发的有益补充。
  3. 2. Spring3.x @Configuration @Bean..
  4. 目的:彻底替换XML,基于纯注解编程
  5. 3. Spring4.x SpringBoot
  6. 提倡使用注解常见开发

5. Spring注解开发的一个问题
  1. Spring基于注解进行配置后,还能否解耦合呢?
  2. Spring框架应用注解时,如果对注解配置的内容不满意,可以通过Spring配置文件进行覆盖的。

第二章、Spring的基础注解(Spring2.x)

  1. 这个阶段的注解,仅仅是简化XML的配置,并不能完全替代XML

1. 对象创建相关注解
  • 搭建开发环境 ```xml

作用:让Spring框架在设置包及其子包中扫描对应的注解,使其生效。

  1. - 对象创建相关注解
  2. - [@Component ](/Component )
  3. ```markdown
  4. 作用:替换原有spring配置文件中的<bean标签
  5. 注意:
  6. id属性 component注解 提供了默认的设置方式 首单词首字母小写
  7. class属性 通过反射获得class内容

image.png

  • @Component 细节

    • 如何显示指定工厂创建对象的id值

      1. @Component("u")
    • Spring配置文件覆盖注解配置内容 ```xml applicationContext.xml

id值 class的值 要和 注解中的设置保持一值 - @Component的衍生注解markdown @Repository —-> XXXDAO @Repository public class UserDAO{ } @Service @Service public class UserService{ } @Controller @Controller public class RegAction{ } 注意:本质上这些衍生注解就是@Component 作用 - @Lazy注解markdown 作用:延迟创建单实例对象 注意:一旦使用了@Lazy注解后,Spring会在使用这个对象时候,进行这个对象的创建 - 生命周期方法相关注解markdown 1. 初始化相关方法 @PostConstruct InitializingBean 2. 销毁方法 @PreDestroy DisposableBean 注意:1. 上述的2个注解并不是Spring提供的,JSR(JavaEE规范)520 2. 再一次的验证,通过注解实现了接口的契约性 <a name="ade574c5"></a> ##### 2. 注入相关注解 - 用户自定义类型 [@Autowired ](/Autowired ) <br /> ![image.png](https://cdn.nlark.com/yuque/0/2020/png/419703/1606059731760-52b81533-6085-4743-ada7-ea949e8a1be2.png#align=left&display=inline&height=234&margin=%5Bobject%20Object%5D&name=image.png&originHeight=234&originWidth=764&size=71321&status=done&style=none&width=764)markdown @Autowired细节 1. Autowired注解基于类型进行注入 [推荐] 基于类型的注入:注入对象的类型,必须与目标成员变量类型相同或者是其子类(实现类) 2. Autowired Qualifier 基于名字进行注入 [了解] 基于名字的注入:注入对象的id值,必须与Qualifier注解中设置的名字相同 3. Autowired注解放置位置 a) 放置在对应成员变量的set方法上 b) 直接把这个注解放置在成员变量之上,Spring通过反射直接对成员变量进行注入(赋值)[推荐] 4. JavaEE规范中类似功能的注解 JSR250 @Resouce(name=”userDAOImpl”) 基于名字进行注入 @Autowired() @Qualifier(“userDAOImpl”) 注意:如果在应用Resource注解时,名字没有配对成功,那么他会继续按照类型进行注入。 JSR330 @Inject 作用 @Autowired完全一致 基于类型进行注入 —-》 EJB3.0 javax.inject javax.inject 1 - JDK类型markdown @Value注解完成 1. 设置xxx.properties id = 10 name = suns 2. Spring的工厂读取这个配置文件 3. 代码 属性 @Value(“${key}”) - [@PropertySource ](/PropertySource )markdown 1. 作用:用于替换Spring配置文件中的标签 2. 开发步骤 1. 设置xxx.properties id = 10 name = suns 2. 应用@PropertySource 3. 代码 属性 @Value() - @Value注解使用细节 - @Value注解不能应用在静态成员变量上markdown 如果应用,赋值(注入)失败 - @Value注解+Properties这种方式,不能注入集合类型markdown Spring提供新的配置形式 YAML YML (SpringBoot) <a name="b05f6ded"></a> ##### 3. 注解扫描详解markdown 当前包 及其 子包 <a name="bbf502b2"></a> ###### 1. 排除方式markdown type:assignable:排除特定的类型 不进行扫描 annotation:排除特定的注解 不进行扫描 aspectj:切入点表达式 包切入点: com.baizhiedu.bean.. 类切入点: ..User regex:正则表达式 custom:自定义排除策略框架底层开发 排除策略可以叠加使用 <a name="d21a1efc"></a> ###### 2. 包含方式xml 1. use-default-filters=”false” 作用:让Spring默认的注解扫描方式 失效。 2. 作用:指定扫描那些注解 type:assignable:排除特定的类型 不进行扫描 annotation:排除特定的注解 不进行扫描 aspectj:切入点表达式 包切入点: com.baizhiedu.bean.. 类切入点: ..User regex:正则表达式 custom:自定义排除策略框架底层开发 包含的方式支持叠加 <a name="fa90efbc"></a> ##### 4. 对于注解开发的思考 - 配置互通markdown Spring注解配置 配置文件的配置 互通 @Repository public class UserDAOImpl{ } public class UserServiceImpl{ private UserDAO userDAO; set get } - 什么情况下使用注解 什么情况下使用配置文件markdown @Component 替换 ##### 5. SSM整合开发(半注解开发) - 搭建开发环境 - 引入相关jar 【SSM POM】 - 引入相关配置文件 - applicationContext.xml - struts.xml - log4.properties - XXXMapper.xml - 初始化配置 - Web.xml Spring (ContextLoaderListener) - Web.xml Struts Filter - 编码 markdown <context:component-scan base-package=""/> - DAO (Spring+Mybatis) markdown 1. 配置文件的配置 1. DataSource 2. SqlSessionFactory ----> SqlSessionFactoryBean 1. dataSource 2. typeAliasesPackage 3. mapperLocations 3. MapperScannerConfigur ---> DAO接口实现类 2. 编码 1. entity 2. table 3. DAO接口 4. 实现Mapper文件 - Service markdown 1. 原始对象 ---》 注入DAO @Service ---> @Autowired 2. 额外功能 ---》 DataSourceTransactionManager ---> dataSource 3. 切入点 + 事务属性 @Transactional(propagation,readOnly...) 4. 组装切面 <tx:annotation-driven - Controller (Spring+Struts2) markdown 1. @Controller @Scope("prototype") public class RegAction implements Action{ @Autowired private UserService userServiceImpl; } 2. struts.xml <action class="spring配置文件中action对应的id值"/> #### 第三章、Spring的高级注解(Spring3.x 及以上) ##### 1. 配置Bean java Spring在3.x提供的新的注解,用于替换XML配置文件。 @Configuration public class AppConfig{ } 1. 配置Bean在应用的过程中 替换了XML具体什么内容呢? image.png 2. AnnotationConfigApplicationContext markdown 1. 创建工厂代码 ApplicationContext ctx = new AnnotationConfigApplicationContext(); 2. 指定配置文件 1. 指定配置bean的Class ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); 2. 指定配置bean所在的路径 ApplicationContext ctx = new AnnotationConfigApplicationContext("com.baizhiedu"); - 配置Bean开发的细节分析 - 基于注解开发使用日志 markdown 不能集成Log4j 集成logback - 引入相关jar xml <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.25</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>jcl-over-slf4j</artifactId> <version>1.7.25</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.3</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-core</artifactId> <version>1.2.3</version> </dependency> <dependency> <groupId>org.logback-extensions</groupId> <artifactId>logback-ext-spring</artifactId> <version>0.1.4</version> </dependency> - 引入logback配置文件 (logback.xml) xml <?xml version="1.0" encoding="UTF-8"?> <configuration> <!-- 控制台输出 --> <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符--> <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern> </encoder> </appender> <root level="DEBUG"> <appender-ref ref="STDOUT" /> </root> </configuration> - @Configuration注解的本质 markdown 本质:也是@Component注解的衍生注解 可以应用<context:component-scan进行扫描 ##### 2. @Bean注解 markdown @Bean注解在配置bean中进行使用,等同于XML配置文件中的<bean标签 ###### 1. @Bean注解的基本使用 - 对象的创建
image.png markdown 1. 简单对象 直接能够通过new方式创建的对象 User UserService UserDAO 2. 复杂对象 不能通过new的方式直接创建的对象 Connection SqlSessionFactory - @Bean注解创建复杂对象的注意事项 java 遗留系统整合 @Bean public Connection conn1() { Connection conn = null; try { ConnectionFactoryBean factoryBean = new ConnectionFactoryBean(); conn = factoryBean.getObject(); } catch (Exception e) { e.printStackTrace(); } return conn; } - 自定义id值 markdown @Bean("id") - 控制对象创建次数 java @Bean @Scope("singleton|prototype") 默认值 singleton ###### 2. @Bean注解的注入 - 用户自定义类型 java @Bean public UserDAO userDAO() { return new UserDAOImpl(); } @Bean public UserService userService(UserDAO userDAO) { UserServiceImpl userService = new UserServiceImpl(); userService.setUserDAO(userDAO); return userService; } //简化写法 @Bean public UserService userService() { UserServiceImpl userService = new UserServiceImpl(); userService.setUserDAO(userDAO()); return userService; } - JDK类型的注入 java @Bean public Customer customer() { Customer customer = new Customer(); customer.setId(1); customer.setName("xiaohei"); return customer; } - JDK类型注入的细节分析 java 如果直接在代码中进行set方法的调用,会存在耦合的问题 @Configuration @PropertySource("classpath:/init.properties") public class AppConfig1 { @Value("${id}") private Integer id; @Value("${name}") private String name; @Bean public Customer customer() { Customer customer = new Customer(); customer.setId(id); customer.setName(name); return customer; } } ##### 3. @ComponentScan注解 markdown @ComponentScan注解在配置bean中进行使用,等同于XML配置文件中的<context:component-scan>标签 目的:进行相关注解的扫描 (@Component @Value ...@Autowired) ###### 1. 基本使用 java @Configuration @ComponentScan(basePackages = "com.baizhiedu.scan") public class AppConfig2 { } <context:component-scan base-package=""/> ###### 2. 排除、包含的使用 - 排除 xml <context:component-scan base-package="com.baizhiedu"> <context:exclude-filter type="assignable" expression="com.baizhiedu.bean.User"/> </context:component-scan> @ComponentScan(basePackages = "com.baizhiedu.scan", excludeFilters = {@ComponentScan.Filter(type= FilterType.ANNOTATION,value={Service.class}), @ComponentScan.Filter(type= FilterType.ASPECTJ,pattern = "*..User1")}) type = FilterType.ANNOTATION value .ASSIGNABLE_TYPE value .ASPECTJ pattern .REGEX pattern .CUSTOM value - 包含 xml <context:component-scan base-package="com.baizhiedu" use-default-filters="false"> <context:include-filter type="" expression=""/> </context:component-scan> @ComponentScan(basePackages = "com.baizhiedu.scan", useDefaultFilters = false, includeFilters = {@ComponentScan.Filter(type= FilterType.ANNOTATION,value={Service.class})}) type = FilterType.ANNOTATION value .ASSIGNABLE_TYPE value .ASPECTJ pattern .REGEX pattern .CUSTOM value ##### 4. Spring工厂创建对象的多种配置方式 ###### 1. 多种配置方式的应用场景 image.png ###### 2. 配置优先级 markdown @Component及其衍生注解 < @Bean < 配置文件bean标签 优先级高的配置 覆盖优先级低配置 @Component public class User{ } @Bean public User user(){ return new User(); } <bean id="user" class="xxx.User"/> 配置覆盖:id值 保持一致 - 解决基于注解进行配置的耦合问题 java @Configuration //@ImportResource("applicationContext.xml") public class AppConfig4 { @Bean public UserDAO userDAO() { return new UserDAOImpl(); } } @Configuration @ImportResource("applicationContext.xml") public class AppConfig5{ } applicationContext.xml <bean id="userDAO" class="com.baizhiedu.injection.UserDAOImplNew"/> ##### 5. 整合多个配置信息 - 为什么会有多个配置信息 markdown 拆分多个配置bean的开发,是一种模块化开发的形式,也体现了面向对象各司其职的设计思想 - 多配置信息整合的方式 - 多个配置Bean的整合 - 配置Bean与@Component相关注解的整合 - 配置Bean与SpringXML配置文件的整合 - 整合多种配置需要关注那些要点 - 如何使多配置的信息 汇总成一个整体 - 如何实现跨配置的注入 ###### 1. 多个配置Bean的整合 - 多配置的信息汇总 - base-package进行多个配置Bean的整合
image.png - @Import markdown 1. 可以创建对象 2. 多配置bean的整合 image.png - 在工厂创建时,指定多个配置Bean的Class对象 【了解】 java ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig1.class,AppConfig2.class); - 跨配置进行注入 java 在应用配置Bean的过程中,不管使用哪种方式进行配置信息的汇总,其操作方式都是通过成员变量加入@Autowired注解完成。 @Configuration @Import(AppConfig2.class) public class AppConfig1 { @Autowired private UserDAO userDAO; @Bean public UserService userService() { UserServiceImpl userService = new UserServiceImpl(); userService.setUserDAO(userDAO); return userService; } } @Configuration public class AppConfig2 { @Bean public UserDAO userDAO() { return new UserDAOImpl(); } } ###### 2. 配置Bean与@Component相关注解的整合 java @Component(@Repository) public class UserDAOImpl implements UserDAO{ } @Configuration @ComponentScan("") public class AppConfig3 { @Autowired private UserDAO userDAO; @Bean public UserService userService() { UserServiceImpl userService = new UserServiceImpl(); userService.setUserDAO(userDAO); return userService; } } ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig3.class); ###### 3. 配置Bean与配置文件整合 java 1. 遗留系统的整合 2. 配置覆盖 public class UserDAOImpl implements UserDAO{ } <bean id="userDAO" class="com.baizhiedu.injection.UserDAOImpl"/> @Configuration @ImportResource("applicationContext.xml") public class AppConfig4 { @Autowired private UserDAO userDAO; @Bean public UserService userService() { UserServiceImpl userService = new UserServiceImpl(); userService.setUserDAO(userDAO); return userService; } } ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig4.class); ##### 6. 配置Bean底层实现原理 markdown Spring在配置Bean中加入了@Configuration注解后,底层就会通过Cglib的代理方式,来进行对象相关的配置、处理 image.png ##### 7. 四维一体的开发思想 ###### 1. 什么是四维一体 markdown Spring开发一个功能的4种形式,虽然开发方式不同,但是最终效果是一样的。 1. 基于schema 2. 基于特定功能注解 3. 基于原始<bean 4. 基于@Bean注解 ###### 2. 四维一体的开发案例 java 1. <context:property-placehoder 2. @PropertySource 【推荐】 3. <bean id="" class="PropertySourcePlaceholderConfigure"/> 4. @Bean 【推荐】 ##### 8. 纯注解版AOP编程 ###### 1. 搭建环境 markdown 1. 应用配置Bean 2. 注解扫描 ###### 2. 开发步骤 java 1. 原始对象 @Service(@Component) public class UserServiceImpl implements UserService{ } 2. 创建切面类 (额外功能 切入点 组装切面) @Aspect @Component public class MyAspect { @Around("execution(* login(..))") public Object arround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect log ------"); Object ret = joinPoint.proceed(); return ret; } } 3. Spring的配置文件中 <aop:aspectj-autoproxy /> @EnableAspectjAutoProxy ---> 配置Bean ###### 3. 注解AOP细节分析 java 1. 代理创建方式的切换 JDK Cglib <aop:aspectj-autoproxy proxy-target-class=true|false /> @EnableAspectjAutoProxy(proxyTargetClass) 2. SpringBoot AOP的开发方式 @EnableAspectjAutoProxy 已经设置好了 1. 原始对象 @Service(@Component) public class UserServiceImpl implements UserService{ } 2. 创建切面类 (额外功能 切入点 组装切面) @Aspect @Component public class MyAspect { @Around("execution(* login(..))") public Object arround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect log ------"); Object ret = joinPoint.proceed(); return ret; } } Spring AOP 代理默认实现 JDK SpringBOOT AOP 代理默认实现 Cglib ##### 9. 纯注解版Spring+MyBatis整合 - 基础配置 (配置Bean) ```xml 1. 连接池

@Bean public DataSource dataSource(){ DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(“”); dataSource.setUrl(); … return dataSource; }

  1. SqlSessionFactoryBean

    classpath:com.baizhiedu.mapper/*Mapper.xml

    @Bean public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){

    1. SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    2. sqlSessionFactoryBean.setDataSource(dataSource);
    3. sqlSessionFactoryBean.setTypeAliasesPackage("");
    4. ...
    5. return sqlSessionFactoryBean;

    }

  2. MapperScannerConfigure

    @MapperScan(basePackages={“com.baizhiedu.dao”}) —-> 配置bean完成 ```

  • 编码 ```markdown
  1. 实体
  2. DAO接口
  3. Mapper文件 ```
    1. MapperLocations编码时通配的写法 ```java //设置Mapper文件的路径 sqlSessionFactoryBean.setMapperLocations(Resource..); Resource resouce = new ClassPathResouce(“UserDAOMapper.xml”)

sqlSessionFactoryBean.setMapperLocations(new ClassPathResource(“UserDAOMapper.xml”));

classpath:com.baizhiedu.mapper/*Mapper.xml 一组Mapper文件

ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(); Resource[] resources = resolver.getResources(“com.baizhi.mapper/*Mapper.xml”); sqlSessionFactoryBean.setMapperLocations(resources)

  1. - 2. 配置Bean数据耦合的问题
  2. ```java
  3. mybatis.driverClassName = com.mysql.jdbc.Driver
  4. mybatis.url = jdbc:mysql://localhost:3306/suns?useSSL=false
  5. mybatis.username = root
  6. mybatis.password = 123456
  7. mybatis.typeAliasesPackages = com.baizhiedu.mybatis
  8. mybatis.mapperLocations = com.baizhiedu.mapper/*Mapper.xml
  9. @Component
  10. @PropertySource("classpath:mybatis.properties")
  11. public class MybatisProperties {
  12. @Value("${mybatis.driverClassName}")
  13. private String driverClassName;
  14. @Value("${mybatis.url}")
  15. private String url;
  16. @Value("${mybatis.username}")
  17. private String username;
  18. @Value("${mybatis.password}")
  19. private String password;
  20. @Value("${mybatis.typeAliasesPackages}")
  21. private String typeAliasesPackages;
  22. @Value("${mybatis.mapperLocations}")
  23. private String mapperLocations;
  24. }
  25. public class MyBatisAutoConfiguration {
  26. @Autowired
  27. private MybatisProperties mybatisProperties;
  28. @Bean
  29. public DataSource dataSource() {
  30. DruidDataSource dataSource = new DruidDataSource();
  31. dataSource.setDriverClassName(mybatisProperties.getDriverClassName());
  32. dataSource.setUrl(mybatisProperties.getUrl());
  33. dataSource.setUsername(mybatisProperties.getUsername());
  34. dataSource.setPassword(mybatisProperties.getPassword());
  35. return dataSource;
  36. }
  37. @Bean
  38. public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
  39. SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
  40. sqlSessionFactoryBean.setDataSource(dataSource);
  41. sqlSessionFactoryBean.setTypeAliasesPackage(mybatisProperties.getTypeAliasesPackages());
  42. //sqlSessionFactoryBean.setMapperLocations(new ClassPathResource("UserDAOMapper.xml"));
  43. try {
  44. ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
  45. Resource[] resources = resolver.getResources(mybatisProperties.getMapperLocations());
  46. sqlSessionFactoryBean.setMapperLocations(resources);
  47. } catch (IOException e) {
  48. e.printStackTrace();
  49. }
  50. return sqlSessionFactoryBean;
  51. }
  52. }

10. 纯注解版事务编程
  1. 1. 原始对象 XXXService
  2. <bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
  3. <property name="userDAO" ref="userDAO"/>
  4. </bean>
  5. @Service
  6. public class UserServiceImpl implements UserService{
  7. @Autowired
  8. private UserDAO userDAO;
  9. }
  10. 2. 额外功能
  11. <!--DataSourceTransactionManager-->
  12. <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  13. <property name="dataSource" ref="dataSource"/>
  14. </bean>
  15. @Bean
  16. public DataSourceTransactionManager dataSourceTransactionManager(DataSource dataSource){
  17. DataSourceTransactionManager dstm = new DataSourceTransactionManager();
  18. dstm.setDataSource(dataSource);
  19. return dstm
  20. }
  21. 3. 事务属性
  22. @Transactional
  23. @Service
  24. public class UserServiceImpl implements UserService {
  25. @Autowired
  26. private UserDAO userDAO;
  27. 4. 基于Schema的事务配置
  28. <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
  29. @EnableTransactionManager ---> 配置Bean
  1. 1. ApplicationContext ctx = new AnnotationConfigApplicationContext("com.baizhiedu.mybatis");
  2. SpringBoot 实现思想
  3. 2. 注解版MVC整合,SpringMVC中进行详细讲解
  4. SpringMyBatis --->DAO 事务基于注解 --> Service Controller
  5. org.springframework.web.context.ContextLoaderListener ---> XML工厂 无法提供 new AnnotationConfigApplicationContext

11. Spring框架中YML的使用

1. 什么是YML
  1. YML(YAML)是一种新形式的配置文件,比XML更简单,比Properties更强大。
  2. YAML is a nice human-readable format for configuration, and it has some useful hierarchical properties. It's more or less a superset of JSON, so it has a lot of similar features.

2. Properties进行配置问题
  1. 1. Properties表达过于繁琐,无法表达数据的内在联系.
  2. 2. Properties无法表达对象 集合类型

3. YML语法简介
  1. 1. 定义yml文件
  2. xxx.yml xxx.yaml
  3. 2. 语法
  4. 1. 基本语法
  5. name: suns
  6. password: 123456
  7. 2. 对象概念
  8. account:
  9. id: 1
  10. password: 123456
  11. 3. 定义集合
  12. service:
  13. - 11111
  14. - 22222

4. Spring与YML集成思路的分析
  1. 1. 准备yml配置文件
  2. init.yml
  3. name: suns
  4. password: 123456
  5. 2. 读取yml 转换成 Properties
  6. YamlPropertiesFactoryBean.setResources( yml配置文件的路径 ) new ClassPathResource();
  7. YamlPropertiesFactoryBean.getObject() ---> Properties
  8. 3. 应用PropertySourcesPlaceholderConfigurer
  9. PropertySourcesPlaceholderConfigurer.setProperties();
  10. 4. 类中 @Value注解 注入

5. Spring与YML集成编码
  • 环境搭建

    1. <dependency>
    2. <groupId>org.yaml</groupId>
    3. <artifactId>snakeyaml</artifactId>
    4. <version>1.23</version>
    5. </dependency>
    6. 最低版本 1.18
  • 编码 ```java

  1. 准备yml配置文件
  2. 配置Bean中操作 完成YAML读取 与 PropertySourcePlaceholderConfigure的创建 @Bean public PropertySourcesPlaceholderConfigurer configurer() {

    1. YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
    2. yamlPropertiesFactoryBean.setResources(new ClassPathResource("init.yml"));
    3. Properties properties = yamlPropertiesFactoryBean.getObject();
    4. PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
    5. configurer.setProperties(properties);
    6. return configurer;

    }

  3. 类 加入 @Value注解 ```

6. Spring与YML集成的问题
  1. 1. 集合处理的问题
  2. SpringEL表达式解决
  3. @Value("#{'${list}'.split(',')}")
  4. 2. 对象类型的YAML进行配置时 过于繁琐
  5. @Value("${account.name}")
  6. SpringBoot @ConfigurationProperties