spring常用注解

　　一、组件注解
　　1、Component（xxx）
　　指定某个类是容器的bean，Component（valuexx）相当于，其中value可以不写。
　　用于标注类为spring容器bean的注解有四个，主要用于区别不同的组件类，提高代码的可读性：
　　a、Component，用于标注一个普通的bean
　　b、Controller用于标注一个控制器类（控制层controller）
　　c、Service用于标注业务逻辑类（业务逻辑层service）
　　d、Repository用于标注DAO数据访问类（数据访问层dao）
　　对于上面四种注解的解析可能是相同的，尽量使用不同的注解提高代码可读性。
　　注解用于修饰类，当不写value属性值时，默认值为类名首字母小写。
　　2、Scope（prototype）
　　该注解和Component这一类注解联合使用，用于标记该类的作用域，默认singleton。
　　也可以和Bean一起使用，此时Scope修饰一个方法。关于Bean稍后有说明
　　3、Lazy（true）
　　指定bean是否延时初始化，相当于，默认false。Lazy可以和Component这一类注解联合使用修饰类，也可以和Bean一起使用修饰方法
　　注：此处初始化不是指不执行initmethod，而是不创建bean实例和依赖注入。只有当该bean（被Lazy修饰的类或方法）被其他bean引用（可以是自动注入的方式）或者执行getBean方法获取，才会真正的创建该bean实例，其实这也是BeanFactory的执行方式。
　　4、DepondsOn（｛aa，bb｝）
　　该注解也是配合Component这类注解使用，用于强制初始化其他beanDepondsOn（other）Lazy（true）ControllerScope（prototype）publicclassUserAction｛。。。。。。。。。。。。。。。｝
　　上面的代码指定，初始化beanuserAction之前需要先初始化aa和bb两个bean，但是使用了Lazy（true）所以spring容器初始化时不会初始化userActionbean。
　　5、PostConstructor和PreDestroy
　　PostConstructor和PreDestroy这两个注解是j2ee规范下的注解。这两个注解用于修饰方法，spring用这两个注解管理容器中spring生命周期行为。
　　a、PostConstructor从名字可以看出构造器之后调用，相当于。就是在依赖注入之后执行
　　b、PreDestroy容器销毁之前bean调用的方法，相当于
　　6、Resource（namexx）
　　Resource可以修饰成员变量也可以修饰set方法。当修饰成员变量时可以不写set方法，此时spring会直接使用j2ee规范的Field注入。
　　Resource有两个比较重要的属性，name和type
　　a、如果指定了name和type，则从Spring容器中找到唯一匹配的bean进行装配，找不到则抛出异常；
　　b、如果指定了name，则从spring容器查找名称（id）匹配的bean进行装配，找不到则抛出异常；
　　c、如果指定了type，则从spring容器中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常；
　　d、如果既没有指定name，又没有指定type，则自动按照byName方式进行装配
　　如果没有写name属性值时
　　a、修饰成员变量，此时name为成员变量名称
　　b、修饰set方法，此时name为set方法的去掉set后首字母小写得到的字符串
　　7、Autowired（requiredfalse）
　　Autowired可以修饰构造器，成员变量，set方法，普通方法。Autowired默认使用byType方式自动装配。required标记该类型的bean是否是必须的，默认为必须存在（true）。
　　可以配合Qualifier（valuexx），实现按beanName注入：
　　a、requiredtrue（默认），为true时，从spring容器查找和指定类型匹配的bean，匹配不到或匹配多个则抛出异常
　　b、使用Qualifier（xx），则会从spring容器匹配类型和id一致的bean，匹配不到则抛出异常
　　Autowired会根据修饰的成员选取不同的类型：
　　a、修饰成员变量。该类型为成员变量类型
　　b、修饰方法，构造器。注入类型为参数的数据类型，当然可以有多个参数
　　8、demo
　　业务逻辑层：service层，业务逻辑ServicepublicclassUserService｛Resource（nameuserDao）privateUserDaouserDAutowiredQualifier（userDao）privateIUserDaouserD相对来说使用Resource更简单一些。。。。。。。实际业务。。。。。。。。。。。。。｝
　　数据访问层：dao层，持久化RepositoryLazy（true）Scope（singleton）publicclassUserDaoimplementsInitializingBean，DisposableBean｛publicUserDao（）｛System。out。println（constructor。。。。。。。。。。。。。。。。。。。）；｝publicListUserlistUsers（）｛System。out。println（查询所有用户）；｝PostConstructpublicvoidpostConstructor（）｛System。out。println（postconstructor。。。。。。。。。。。。。。。。。）；｝覆盖InitializingBean接口方法OverridepublicvoidafterPropertiesSet（）throwsException｛System。out。println（afterpropertiesset。。。。。。。。。。。。。。）；｝PreDestroypublicvoidafter（）｛System。out。println（predestroty。。。。。。。。。。。。。。。。。）；｝重写DisposableBean方法Overridepublicvoiddestroy（）throwsException｛System。out。println（destrymethod。。。。。。。。。。。。。）；｝｝
　　测试类：测试类publicclassTestAnnotation｛Testpublicvoidtest1（）｛ClassPathXmlApplicationContextapplicationnewClassPathXmlApplicationContext（applicationContext。xml）；配置文件里只有一行就是开启自动扫描context：componentscanbasepackagecomSystem。out。println（）；System。out。println（获取bean）；System。out。println（）；System。out。println（application。getBean（userDao））；关闭容器，就会销毁容器中的beanapplication。close（）；｝｝
　　输出结果：constructor。。。。。。。。。。。。。。。。。。。postconstructor。。。。。。。。。。。。。。。。。afterpropertiesset。。。。。。。。。。。。。。获取beancom。dao。PersonManager4872669fpredestroty。。。。。。。。。。。。。。。。。destry。。。。。。。。。。。。。predestroty。。。。。。。。。。。。。。。。。destry。。。。。。。。。。。。。
　　可以看到虽然UserDao使用Lazy，但是还是在spring容器初始化的时候还是创建了UserDao实例。原因很简单，因为在UserService中需要注入UserDao，所以在此时创建的UserDao实例也属于延时初始化。
　　在上面我们还使用了两个接口InitializingBean和DisposableBean，这两个接口用于管理singleton作用域的bean的生命周期，类似initmethod和destroymethod。不同之处就是调用的循序不一致：
　　a、初始化调用顺序：PostConstructorInitializingBeaninitmethod用于指定bean依赖注入后的行为
　　b、销毁调用顺序PreDestroyDisposableBeandestroymethod用于定制bean销毁之前的行为
　　二、Aop相关注解
　　该注解是AspectJ中的注解，并不是spring提供的，所以还需要导入aspectjweaver。jar，aspectjrt。jar，除此之外还需要依赖aopalliance。jar
　　依赖包：dependencygroupIdaopalliancegroupIdaopallianceartifactIdversion1。0versiondependencydependencygroupIdorg。aspectjgroupIdaspectjweaverartifactIdversion1。9。2versiondependencydependencygroupIdorg。aspectjgroupIdaspectjrtartifactIdversion1。5。4versiondependency
　　UserDao。javapackagecom。example。importcom。example。domain。Uimportorg。springframework。stereotype。Rimportjava。util。ArrayLimportjava。util。LRepositorypublicclassUserDao｛publicUserDao（）｛System。out。println（constructor。。。。。。。。。。。。。。。。。。。）；｝publicListUserlistUsers（）｛System。out。println（查询所有用户）；returnnewArrayList（）；｝｝
　　配置文件applicationContext。xml：？xmlversion1。0encodingUTF8？beansxmlnshttp：www。springframework。orgschemabeansxmlns：contexthttp：www。springframework。orgschemacontextxmlns：xsihttp：www。w3。org2001XMLSchemainstancexmlns：aophttp：www。springframework。orgschemaaopxsi：schemaLocationhttp：www。springframework。orgschemabeanshttp：www。springframework。orgschemabeansspringbeans3。0。xsdhttp：www。springframework。orgschemacontexthttp：www。springframework。orgschemacontextspringcontext3。0。xsdhttp：www。springframework。orgschemaaophttp：www。springframework。orgschemaaopspringaop3。0。xsdcontext：componentscanbasepackagecom！自动扫描aop：aspectjautoproxy！开启AspectJ支持beans
　　测试类：publicclassTestAnnotation｛Testpublicvoidtest1（）｛ClassPathXmlApplicationContextapplicationnewClassPathXmlApplicationContext（applicationContext。xml）；配置文件里只有一行就是开启自动扫描context：componentscanbasepackagecomUserDaouserDaoapplication。getBean（userDao，UserDao。class）；System。out。println（返回结果：userDao。listUsers（））；｝｝
　　1、Aspect
　　修饰Java类，指定该类为切面类。当spring容器检测到某个bean被Aspect修饰时，spring容器不会对该bean做增强处理（bean后处理器增强，代理增强）packagecom。example。importorg。aspectj。lang。ProceedingJoinPimportorg。aspectj。lang。annotation。；importorg。springframework。stereotype。CComponentAspectpublicclassUserAdvice｛｝
　　2、Before
　　修饰方法，before增强处理。用于对目标方法（切入点表达式表示方法）执行前做增强处理。可以用于权限检查，登陆检查。
　　常用属性：
　　value：指定切入点表达式或者引用一个切入点
　　对com。example。aop包下所有的类的所有方法做before增强处理：Before（valueexecution（com。example。aop。（。。））））publicvoidbefore（JoinPointjoinPoint）｛System。out。println（before增强处理）；｝
　　结果：constructorbefore增强处理查询所有用户返回结果：〔〕
　　如果同一条切入点表达式被使用多次，可以使用更友好的方式。定义一个切入点：Pointcut（execution（com。example。aop。（。。））））publicvoidaddLog（）｛｝Before（valueaddLog（））publicvoidbefore（JoinPointjoinPoint）｛System。out。println（before增强处理）；｝
　　增强方法可以接受一个JoinPoint类型的参数，用于获取被执行目标方法的一下属性。Before（valueaddLog（））publicvoidexecute（JoinPointjoinPoint）｛System。out。println（before增强处理）；System。out。println（Arrays。toString（joinPoint。getArgs（）））；System。out。println（joinPoint。getKind（））；System。out。println（joinPoint。getSignature（）。getName（））；System。out。println（joinPoint。getSignature（）。getDeclaringTypeName（））；System。out。println（joinPoint。getSignature（）。getDeclaringType（））；System。out。println（joinPoint。getSignature（）。getModifiers（））；System。out。println（joinPoint。getSourceLocation（））；System。out。println（joinPoint。getTarget（））；System。out。println（joinPoint。getThis（））；｝
　　结果：constructorbefore增强处理〔〕methodexecutionlistUserscom。example。aop。UserDaoclasscom。example。aop。UserDao1org。springframework。aop。aspectj。MethodInvocationProceedingJoinPointSourceLocationImpl15d49048com。example。aop。UserDao7098b907com。example。aop。UserDao7098b907查询所有用户
　　3、AfterReturning
　　修饰方法，afterreturning增强处理。目标方法正常结束后做增强处理。
　　常用属性：
　　a、pointcutvalue：指定切入点表达式
　　b、returning：指定一个参数名，用于接受目标方法正常结束时返回的值。参数名称需要在增强方法中定义同名的参数。
　　注意：
　　a、如果使用了returning。那么增强方法中的数据类型必须是返回结果的类型或者父类型，否则不会调用该增强处理。
　　b、使用了returning还可以用来修改返回结果。
　　以上面的例子来说，目标方法返回结果类型应该满足下面的条件returnResultinstanceofList
　　修改返回值：AfterReturning（pointcutaddLog（），returninglist）publicvoidafterReturning（JoinPointjoinPoint，Listlist）｛System。out。println（afterReturning。。。。。。。。。。。。。。）；System。out。println（afterReturning接收结果list）；修改返回结果list。add（newUser（3L，afterReturning。。。。。。））；｝
　　结果：constructorbefore增强处理查询所有用户afterReturningafterReturning接收结果〔〕接口返回结果：〔User｛id3，name‘afterReturning’｝〕
　　可以看到AfterReturning修改了返回结果。
　　4、AfterThrowing
　　修饰方法，afterthrowing增强处理。当目标程序方法抛出异常或者异常无法捕获时，做增强处理。
　　常用属性：
　　a、pointcutvalue：指定切入点表达式
　　b、throwing：指定一个形参，在增强方法中定义同名形参，用于访问目标方法抛出的异常
　　AfterThrowing（pointcutaddLog（），throwinge）publicvoidafterThrowing（JoinPointjoinPoint，Exceptione）｛System。out。println（afterThrowing。。。。。。。。。。。。。。）；System。out。println（抛出异常e）；｝
　　参数类型必须是Throwable的子类，同样也会有上面AfterReturning参数类型匹配的问题。
　　5、After
　　修饰方法，after增强处理。无论方法是否正常结束，都会调用该增强处理（AfterAfterReturningAfterThrowing）。但是该增强方式无法获取目标方法的返回结果，也获取目标方法抛出的异常。所以一般用于进行释放资源，功能类似于finally。
　　常用属性：
　　a、value：指定切入点表达式After（addLog（））publicObjectafter（JoinPointjoinPoint）｛System。out。println（after。。。。。。。。。。。。。。）；试图修改返回结果ListUserlistnewArrayList（）；list。add（newUser（1L，after。。。。。））；｝
　　结果：constructorbefore增强处理查询所有用户afterafterReturningafterReturning接收结果〔〕接口返回结果：〔User｛id3，name‘afterReturning’｝〕
　　从上面的结果来看After增加处理，因为不能接受返回结果作为参数，所以不能修改返回结果。
　　6、Around
　　修饰方法，around增强处理。该处理可以目标方法执行之前和执行之后织入增强处理（BeforeAfterReturning）。
　　Around增强处理通常需要在线程安全的环境下使用，如果Before和AfterReturning可以处理就没必要使用Around。
　　常用属性：
　　a、value：指定切入点表达式
　　当定义一个Aound增前处理时，增强方法第一形参需要时ProceedingJoinPoint类型。ProceedingJoinPoint有一个Objectproceed（）方法，用于执行目标方法。当然也可以为目标方法传递数组参数，来修改目前方法的传入参数。publicinterfaceProceedingJoinPointextendsJoinPoint｛voidsetAroundClosure（AroundClosurevar1）；Objectproceed（）throwsT修改目标方法的传参Objectproceed（Object〔〕var1）throwsT｝
　　around小结：
　　a、Around增强处理通常需要在线程安全的环境下使用
　　b、调用proceed（）可以获取返回结果，所以可以修改目标方法的返回值
　　c、proceed（Object〔〕var1）可以修改入参，修改目标方法的入参
　　d、可以进行目标方法执行之前和执行之后织入增强处理
　　around和afterReturning都可以修改返回结果。不过两者的原理不同：
　　a、around：可以任意修改，或者返回不相关的值。这个返回值完全可以自主控制
　　b、afterReturning，通过方法参数，使用对象引用的方式来修改对象。修改对象引用地址那么修改时无效的
　　除此之外从输出结果来看，增强处理是有序的：
　　around和afterReturning小结：
　　a、只有around和afterReturning可以获取并修改返回结果。需要注意两种方式修改的区别。
　　b、around需要线程安全
　　c、虽然增强处理都需要切入点表达式，并不是都支持pointcut属性，所以最好都是用value属性指定。当注解只需要value属性时，value可以省略Before（valueexecution（com。example。aop。（。。））））Before（execution（com。example。aop。（。。））））
　　7、Pointcut
　　修饰方法，定义一个切入点表达式用于被其他增强调用。使用该方式定义切入点方便管理，易复用。
　　切入点方法定义和测试方法定义类似，具有以下特点：
　　a、无返回值（void）
　　b、无参数
　　c、方法体为空
　　d、方法名就是切入点名称
　　e、方法名不能为executionPointcut（execution（user（。。）））使用一个返回值为void，空方法体的方法命名切入点。public为修饰符，跟方法的修饰符一致，public可以在其他切面类中使用该切点，default在同一个包下的切面类中使用该切点返回值必须为void，方法名就是定义的切点名称publicvoiduserAdvice（）｛｝
　　切入点表达式
　　切入点表达式可以通过、、！连接
　　1）、execution表达式：execution（（。。））匹配所有包及其子包下所有类的所有方法execution（com。。（。。））匹配com包及其子包下所有类的所有方法execution（com。example。。（。。））匹配com。example包及其子包下所有类的所有方法execution（com。example。。get（。。））匹配com。example包及其子包下所有类的所有get方法execution（com。example。。Controller。（。。））匹配com。example包及其子包下，以Controller结尾的所有方法
　　2）、within表达式：
　　a、匹配指定类下的所有方法。
　　b、匹配执行包及其子包下所有类的所有方法。within（com。example。。）匹配com。example包及其子包下所有类的所有方法within（com。example。）匹配com。example包下所有类的所有方法（不包括子包）within（com。example。aop。UserDao）匹配UserDao类下的所有方法
　　所以within可以看做execution的简写，不需要指定返回类型、方法名、参数（最小作用单位是类）within（com。。）execution（com。。（。。））
　　3）、annotation：匹配使用指定注解修饰的目标方法；Before（annotation（com。example。aop。CustomMethodAnnotation））
　　匹配使用CustomMethodAnnotation注解的目标方法。
　　4）、within：用于匹配使用指定注解修饰的类下的所有方法
　　within作用范围是类，within的作用范围与其一致。不同的是within指定的不是类而是注解Before（within（org。springframework。web。bind。annotation。ResponseBody））
　　匹配使用ResponseBody注解的类下的所有方法。
　　不同的切入点表达式声明方式顺序也是不同的：
　　切入点表达式不同声明方式的顺序
　　AOP小结：
　　1）、Around增强处理通常需要在线程安全的环境下使用
　　2）、使用around和afterReturning可以获取并修改返回结果
　　3）、增强处理指定切入点表达式时，最好使用value属性
　　4）、切入点名称（方法名）不能为execution
　　5）、AfterReturning指定了returning属性接受目标方法返回结果，注意参数类型需要和返回结果类型一致（满足resutTypeinstanceofargsType）
　　增强方式的顺序：
　　切入点表达式不同声明方式的顺序：
　　三、Java配置类相关注解
　　1、Bean（namexxx）
　　修饰方法，该方法的返回值为spring容器中管理的bean。当然该注解和上面的Component效果一样，主要用于做区分。
　　Bean通常使用在Configuration修饰的配置类中，该注解功能相当于元素
　　常用的属性：
　　a、name：beanid。name可以省略，省略时bean名称为方法名。也可以指定多个名称（逗号隔开）。
　　b、autowire：是否自动注入，默认Autowire。NO
　　c、initMethod：bean的初始化方法。在依赖注入之后执行
　　d、destroyMethod：spring容器关闭时bean调用的方法
　　当然Bean还可以配合Scope指定bean的作用域BeanpublicUseruser（）｛returnnewUser（）；｝
　　2、ConfigurationProperties
　　用于从属性文件中获取值application。properties或者application。yml。当然了如果在配置文件中引入其他配置文件，也可以获取到属性值。开发环境的配置文件applicationdev。properties通常会配置三套，生产，测试，本地将通用部分配置存放在application。yml，譬如数据库连接等信息存放在applicationxxx。yml中。这样不用每次都要繁琐的修改。spring。profiles。activedev
　　包含的属性：
　　a、valueprefix两者互为别名。指定前缀，默认为
　　b、ignoreUnknownFields：默认为true。是否忽略未知字段，当实体中的字段在配置文件中不存在时，是忽略还是抛出异常
　　c、ignoreInvalidFields：默认false。是否忽略不合法的字段，此处的不合法是指类型不合适，配置文件中存在改配置但是无法转化为指定的字段类型。
　　Mybatis属性配置
　　application。properties：配置mybatismybatis。configuration。mapperLocationsclasspath：mybatismapper。xmlmybatis。configuration。typeAliasPackagecom。example。domainmybatis。configuration。configLocationclasspath：mybatismybatisconfig。xml
　　ConfigurationProperties可以配置前缀，然后会根据实体的变量名拼接前缀，去配置文件中查询配置。ComponentConfigurationProperties（prefixmybatis。configuration）DatapublicclassMybatisProperties｛privateStringconfigL配置文件的路径等价于Value（mybatis。configuration。configLocation）privateStringmapperL配置Mapper映射文件的路径privateStringtypeAliasP别名的实体路径｝
　　3、Configuration
　　修饰一个Java类，被修饰的类相当于一个xml配置文件。功能类似于。在springboot中大量使用了该注解，该注解提供了一种使用Java类方式配置bean。Target（｛ElementType。TYPE｝）Retention（RetentionPolicy。RUNTIME）DocumentedComponentpublicinterfaceConfiguration｛AliasFor（annotationComponent。class）Stringvalue（）｝
　　可以发现Configuration使用了Component注解修饰。
　　实例：
　　配置Mybatis会话工厂ConfigurationAutoConfigureAfter（DataSourceConfig。class）publicclassMyBatisConfig｛AutowiredprivateDataSourcedataSAutowiredMybatisPropertiesmybatisPBean（namesqlSessionFactory）PrimarypublicSqlSessionFactorygetSqlSessionFactory（）throwsException｛SqlSessionFactoryBeanfactoryBeannewSqlSessionFactoryBean（）；factoryBean。setDataSource（dataSource）；配置数据源factoryBean。setTypeAliasesPackage（mybatisProperties。getTypeAliasPackage（））；实体类所在包factoryBean。setConfigLocation（newDefaultResourceLoader（）。getResource（mybatisProperties。getConfigLocation（）））；mapper配置文件factoryBean。setMapperLocations（newPathMatchingResourcePatternResolver（）。getResources（mybatisProperties。getMapperLocations（）））；Mapper实体类所在路径returnfactoryBean。getObject（）；｝BeanpublicSqlSessionTemplatesqlSessionTemplate（SqlSessionFactorysqlSessionFactory）｛returnnewSqlSessionTemplate（sqlSessionFactory）；｝事务管理器BeanpublicPlatformTransactionManagergetDatasourceManager（）｛returnnewDataSourceTransactionManager（dataSource）；｝｝
　　4、Import
　　功能和类似，修饰Java类，用于向当前类导入其他配置类。可以导入多个配置文件，通常用于导入不在包扫描范围内的配置文件。可以被扫描的配置类可以直接访问，没有必要使用Import导入。
　　比如SpringBoot的启动类指定的包扫描路径为com。exampleSpringBootApplicationComponentScan（com。example）MapperScan（com。example。mapper）publicclassApplication｛publicstaticvoidmain（String〔〕args）｛SpringApplication。run（Application。class，args）；｝｝
　　数据库的配置文件在com包下。ConfigurationpublicclassDataSourceConfig｛AutowiredprivateJdbcPBean（namedataSource）PrimarypublicDataSourcegetSqlDataSource（）throwsSQLException｛DruidDataSourcedatasourcenewDruidDataSource（）；。。。。。。。。。。。。。。。。。。。。。。。。。。。。｝｝
　　在MyBatisConfig中引入DataSourceConfig，就会解析DataSourceConfig。将解析出的Bean交给容器管理ConfigurationAutoConfigureAfter（DataSourceConfig。class）Import（DataSourceConfig。class）publicclassMyBatisConfig
　　5、ImportResource
　　修饰Java类，用于向类引入xml配置文件。
　　用于导入包含bean定义的配置文件，功能和类似。默认情况下可以处理后缀为。groovy和。xml的配置文件AliasFor（locations）String〔〕value（）default｛｝；ImportResource（｛classpath：configbeans。xml｝）
　　6、Value（｛expression｝）
　　修饰成员变量或者方法、构造器的参数，用于属性值注入（在配置文件中配置的值）。
　　注意：Value不能对static属性注入。
　　如果的确需要注入到静态变量，可以通过以下方式间接进行注入：
　　1）、设置一个私有静态实例
　　2）、通过构造函数或者PostConstruct注解为静态实例赋值，指向本身（this）
　　3）、对成员属性注入内容
　　4）、提供静态方法，使用静态实例获取成员属性ComponentpublicclassAMSTopicConfig｛privatestaticAMSTopicConfigsingleOValue（｛njbp。mam。op。to。etl。entertainer。tag：njbpmamoptoetlentertainertag｝）privateStringmergePersonTPostConstructpublicvoidinit（）｛为静态属性赋值AMSTopicConfig。singleO｝publicstaticStringgetMergePersonTopic（）｛returnsingleObj。mergePersonT｝｝
　　7、PropertySource（valueclasspath：jdbc。properties）
　　该注解用来加载属性文件。
　　常用属性：
　　a、ignoreResourceNotFound：当资源文件找不到的时候是否会忽略该配置，而不是抛出错误。一般用于可选项
　　b、encoding：资源文件使用什么编码方式
　　c、value：指定属性文件位置。可以配置多个属性文件，不可以使用通配符。
　　在PropertySource中可以指定多个路径，并且会将属性文件中的值加载到Environment中。
　　ConfigurationProperties和PropertySource
　　它们的使用有一些差异：
　　1）、PropertySource使用该注解加载的是相对独立的属性文件，可以同时加载多个文件（xxx。properties），而且不支持自动注入，不支持前缀注入
　　2）、ConfigurationProperties用于加载配置文件（application。propertiesapplication。yml）。该注解功能更强大：
　　a、支持前缀注入（prefix）
　　b、相同属性名的自动注入
　　c、（）支持EL表达式注入
　　应用实例：
　　在以往的开发中通常会将数据库连接信息存放在单独的属性文件中（jdbc。properties）。而在springboot中我们会将数据库的信息存放在配置文件中，这会极大便利开发工作。
　　jdbc。properties：数据源配置spring。datasource。urlxxxxxxxxspring。datasource。usernamexxxx。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
　　可以通过Value注解将配置文件的值注入到实体类中ConfigurationPropertySource（classpath：jdbc。properties）DatapublicclassJdbcProperties｛Value（｛spring。datasource。maxActive｝）privateSValue（｛spring。datasource。maxActive｝）privateS。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。｝
　　也可以注入Environment，通过Environment获取值ConfigurationPropertySource（classpath：jdbc。properties）publicclassAppConfig｛AutowiredEBeanpublicUseruser（）｛System。out。println（env。getProperty（spring。datasource。url））；returnnewUser（）；｝｝
　　四、SpringMVC相关注解
　　1、ResponseBody
　　控制器方法返回值会使用HttpMessageConverter进行数据格式化，转化为JSON字符串。
　　同样的ResponseBodyAdvice：针对使用ResponseBody的注解的类，方法做增强处理。
　　2、RestControllerTarget（｛ElementType。TYPE｝）Retention（RetentionPolicy。RUNTIME）DocumentedControllerResponseBodypublicinterfaceRestController
　　RestControllerControllerResponseBody，所以通常直接使用RestController注解
　　3、RequestBody
　　从Reuqest请求体中获取内容，绑定到方法的指定参数上。SpringMVC使用HttpMessageConverter接口将请求体中的数据转化为方法参数类型。
　　SpringMVC给用户对参数的处理提供了很大支配权。我们可以使用接口RequestBodyAdvice来实现对参数进行拦截处理。
　　注意
　　1）、RequestBodyAdvice：针对所有以RequestBody的参数做处理
　　2）、自定义的处理对象类上必须得加上ControllerAdvice注解！
　　利用此功能我们可以做以下处理工作：
　　1）、参数做解密处理。
　　2）、修改接受的参数数据。
　　4、RequestParam
　　从Request请求中获取指定的参数。
　　可以设置的属性：
　　1）、required：默认为true参数必须存在。参数不存在时抛出异常（MissingServletRequestParameterException）。提示信息
　　2）、defaultValue：设置参数默认值。当参数没有提供或者为空值时生效，包含隐式定义requiredfalse
　　3）、namevalue，互为别名的属性，绑定请求中的参数名。request。getParameter（name）；
　　5、RequestMapping
　　用于设置请求和Method的映射关系。指明何种请求可以和方法匹配
　　可配置属性值：
　　1）、path、value、name，互为别名，设置可以处理的url。
　　2）、consumes，字符串数组。指定可以处理的媒资类型，仅当请求头中的ContentType与其中一种媒体类型匹配时，才会映射请求。所以该配置会缩小可匹配的请求。当url匹配但是consumes不匹配时，状态码415。不设置的话，表示不限制媒资类型，参数的具体使用何种方式解析，SpringMVC会选择合适的处理器处理。
　　3）、produces，字符串数组。生成的媒资类型，该属性会影响实际的输出类型。和consumes一样，改配置会缩小匹配的范围。只有当请求头中的Accept与配置的任意一个媒资类型匹配时，才会映射请求。当url匹配与consumes不匹配时，状态码406。比如：为了生成UTF8编码的JSON响应，应使用MediaType。APPLICATIONJSONUTF8VALUE。