陶瓷网站建设中企动力,建网站的宽带多少,高端网约车有哪些平台,云南省建设厅定额网站基于注解方式管理Bean
1.通过注解管理Bean
1) 基础注解
Component Service Controller Repository
2) 基于XML的注解扫描
a 引入依赖
spring-aop-5.1.5.RELEASE.jarb 开启组件扫描
最简单的开启注解
context:component-scan base-packagecom.jiananComponent Service Controller Repository
2) 基于XML的注解扫描
a 引入依赖
spring-aop-5.1.5.RELEASE.jarb 开启组件扫描
最简单的开启注解
context:component-scan base-packagecom.jianan /默认是4个注解都可以创建对象但是我们也可以自定义可以指定哪些组件也可以排除哪些组件
可以详细设置一些内容
!--use-default-filters 设置是否使用默认的创建注解--
context:component-scan base-packagecom.jianan use-default-filtersfalse!--规定哪些注解 不能 创建对象--
!-- context:exclude-filter typeannotation expressionorg.springframework.stereotype.Component/--!--规定哪些注解 可以 创建对象--context:include-filter typeannotation expressionorg.springframework.stereotype.Controller/
/context:component-scanc 在类上面添加注解创建注解
3) 基于注解开启注解扫描
Configuration
// 开启注解扫描
ComponentScan(basePackages {com.atguigu})
public class SpringConfig {
}4) ComponentScan
上面介绍到ComponentScan用于开始注解扫描那么看一下该注解的源码
1.ComponentScan value指定要扫描的包 2.excludeFilters Filter[] 指定扫描排除的组件 3.includeFilters Filter[] 指定包含哪些组件 4.Filter 默认扫描注解类型也可以自定义 5.当指定扫描组件的时候需要禁用默认扫描组件 useDefaultFilters false 6.ComponentScan注解类上有Repeatable注解,代表是可重复注解 7.我们也可以通过ComponentScans[]来些多个注解扫描方式
Retention(RetentionPolicy.RUNTIME)
Target({ElementType.TYPE})
Documented
Repeatable(ComponentScans.class)// 这个的 Repeatable代表是一个重复注解,即可以重复使用
public interface ComponentScan {AliasFor(value)String[] basePackages() default {};// 是否使用默认的4个注解boolean useDefaultFilters() default true;// 指定包含哪些组件ComponentScan.Filter[] includeFilters() default {};// 指定扫描排除的组件ComponentScan.Filter[] excludeFilters() default {};// 省略一些代码...
}使用示例
Configuration
// ComponentScan value指定要扫描的包
// excludeFilters Filter[] 指定扫描排除的组件
ComponentScan(value com.jianan, excludeFilters {ComponentScan.Filter(type FilterType.ANNOTATION, classes {Controller.class, Service.class})
})
// includeFilters Filter[] 指定包含哪些组件
// 当指定扫描组件的时候需要禁用默认的扫描组件 useDefaultFilters false
ComponentScan(value com.jianan, includeFilters {ComponentScan.Filter(type FilterType.ANNOTATION, classes {Controller.class, Service.class})
},useDefaultFilters false)
public class MainConfig {
}FilterType
在ComponentScan我们可以指定过滤的类型按照注解、类等扫描也可以按照自定义的扫描
public enum FilterType {ANNOTATION,// 按照注解扫描ASSIGNABLE_TYPE,// 按照给定的类型扫描ASPECTJ, // 使用ASPECTJ表达式REGEX, // 使用正则指定CUSTOM; // 使用自定义表达式private FilterType() {}
}自定义过滤类型
1)创建类实现TypeFilter接口
public class MyTypeFilter implements TypeFilter {/**** param metadataReader 读取到当前正在扫描的类的信息* param metadataReaderFactory 可以获取到其它任何类的信息* return* throws IOException*/Overridepublic boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {// 获取当前类注解的信息AnnotationMetadata annotationMetadata metadataReader.getAnnotationMetadata();// 获取当前正在扫描的类的类信息ClassMetadata classMetadata metadataReader.getClassMetadata();// 获取当前类资源(类的路径)Resource resource metadataReader.getResource();String className classMetadata.getClassName();System.out.println(----- className);return false;}
}2)配置类设置
Configuration
ComponentScan(value com.jianan, includeFilters {ComponentScan.Filter(type FilterType.CUSTOM, classes {MyTypeFilter.class})
},useDefaultFilters false)
public class MainConfig {
}3)测试 public static void main(String[] args) {// 通过注解配置类AnnotationConfigApplicationContext applicationContext new AnnotationConfigApplicationContext(MainConfig.class);// 获取Person类在IOC容器中名字String[] names applicationContext.getBeanDefinitionNames();for (String name : names) {System.out.println(name);//person1}}5) Configuration
上面可以注解 注解扫描来创建对象那么其创建的都是通过调用无参构造方法那么我们想在创建的时候同时注入属性可以通过
Configuration //作为配置类替代 xml 配置文件
ComponentScan(basePackages {com.atguigu})
public class SpringConfig { Beanpublic User user(){User user new User();// 可以在这里设置对象属性user.setId(1);return user; }
}该注解存在2个属性 value()属性很好理解对应Component注解的value proxyBeanMethods() 从注释上看到是从5.2开始推出的意思就是代理Bean的方法当属性值不同时代表两种模式 Full(proxyBeanMethods true)、全量模式【保证每个Bean方法被调用多少次返回的组件都是单实例的】 Lite(proxyBeanMethods false)、增量模式【每个Bean方法被调用多少次返回的组件都是新创建的】 组件依赖必须使用Full模式。也就是在一个配置类里面一个组件的注册依赖了另外一个类此时必须保证组件是单实例也就是在获取的时候需要先检查是否已经创建了 其他默认是Lite模式这样容器在启动的时候就没有必要检测是否已经存在该实例可以加快容器启动速度
Target({ElementType.TYPE})
Retention(RetentionPolicy.RUNTIME)
Documented
Component // 这里有Component 代表配置类里面的Bean会注册组件,同时配置类本身也是组件
public interface Configuration {// 该注解代表将value值映射到ComponentAliasFor(annotation Component.class)String value() default ;/*** Specify whether {code Bean} methods should get proxied in order to enforce* bean lifecycle behavior, e.g. to return shared singleton bean instances even* in case of direct {code Bean} method calls in user code. This feature* requires method interception, implemented through a runtime-generated CGLIB* subclass which comes with limitations such as the configuration class and* its methods not being allowed to declare {code final}.* pThe default is {code true}, allowing for inter-bean references via direct* method calls within the configuration class as well as for external calls to* this configurations {code Bean} methods, e.g. from another configuration class.* If this is not needed since each of this particular configurations {code Bean}* methods is self-contained and designed as a plain factory method for container use,* switch this flag to {code false} in order to avoid CGLIB subclass processing.* pTurning off bean method interception effectively processes {code Bean}* methods individually like when declared on non-{code Configuration} classes,* a.k.a. Bean Lite Mode (see {link Bean Beans javadoc}). It is therefore* behaviorally equivalent to removing the {code Configuration} stereotype.* since 5.2*/boolean proxyBeanMethods() default true;
}proxyBeanMethods 测试
SpringBootApplication
public class BootApplication {public static void main(String[] args) {// 1.获取容器SpringApplication application new SpringApplication(BootApplication.class);// 2.容器启动,返回启动启动后的IOC容器ConfigurableApplicationContext context application.run(args);// 获取到配置类,因为配置类也是组件UserConfig userConfig context.getBean(UserConfig.class);// 调用方法获取组件User user1 userConfig.user();User user2 userConfig.user();// 根据proxyBeanMethods配置的不同来判断 多次创建的组件是否为单实例System.out.println(user1 user2);}}proxyBeanMethods 原理
该属性的实现原理根据这个属性名就猜到肯定是用到了代理
如果proxyBeanMethods true那么肯定会经过代理中间会先尝试从容器中获取Bean获取到直接返回否则就是第一次创建这样就保证了单实例
如果proxyBeanMethods false那么就不用代理了直接最简单调用依次创建一个
使用示例
在Spring的声明式事务中EnableTransactionManagement注解会向容器中导入两个类AutoProxyRegistrar和ProxyTransactionManagementConfiguration
其中引入的第2个类就用到了proxyBeanMethods 这里设置的是false因为事务注解Transaction是加在方法上的这样每个方法的注解属性就可能不一样所以就不能设置单例的
// 因为每个方法可能需要回滚的方式不同,所以这里使用的false
Configuration(proxyBeanMethods false)
Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {Bean(name TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)Role(BeanDefinition.ROLE_INFRASTRUCTURE)public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {BeanFactoryTransactionAttributeSourceAdvisor advisor new BeanFactoryTransactionAttributeSourceAdvisor();advisor.setTransactionAttributeSource(transactionAttributeSource);advisor.setAdvice(transactionInterceptor);if (this.enableTx ! null) {advisor.setOrder(this.enableTx.IntegergetNumber(order));}return advisor;}BeanRole(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionAttributeSource transactionAttributeSource() {return new AnnotationTransactionAttributeSource();}BeanRole(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {TransactionInterceptor interceptor new TransactionInterceptor();interceptor.setTransactionAttributeSource(transactionAttributeSource);if (this.txManager ! null) {interceptor.setTransactionManager(this.txManager);}return interceptor;}}6) Bean
Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
Retention(RetentionPolicy.RUNTIME)
Documented
public interface Bean {AliasFor(name)String[] value() default {};AliasFor(value)String[] name() default {};/** deprecated */DeprecatedAutowire autowire() default Autowire.NO;boolean autowireCandidate() default true;// 初始化方法String initMethod() default ;// 销毁方法String destroyMethod() default (inferred);
}2.Bean注解
Autowired
1. 该注解属于org.springframework.beans.factory.annotation也就是它是Spring框架提供的
2. 默认优先按照类型去容器中找对应的组件 application.getBean(Car.class)
3. 如果找到多个相同类型的组件,再将属性的名称作为组件的id去容器中查找
4. Qualifier() 使用该注解指定需要装配的组件id 而不是使用属性名
5. 自动装配一定要将属性赋值好没有就报错
6. Autowired(required false) 代表找到类型赋值最好找不到就报错
7. Primary 当我们需要获取的对象存在多个时我们可以通过该注解标注首选代表哪个的优先级最高public interface Autowired {// 设置是否允许Null值boolean required() default true;
}Component
Primary //代表当获取的对象存在多个时可以通过注解标注首选
public class User {
}Qualifier
如果我们要使用名称装备,Autowired可以结合Qualifier注解进行使用 例如: Autowired Qualifier(“life”)//按照byName来自动注入 private Life life;
Resource
该注解属于javax.annotation它是JDK提供的如果没有指定name属性当注解写在字段上时默认取字段名进行安装名称查找如果name属性一旦指定就只会按照名称进行装配
Value
基本数据可以写SpEL表达式; #{}可以写 ${} 取出配置文件中的值
Value(张三)
private String name;Value(#{20-2})
private Integer age;Value(${spring.sex})
private String sex;PropertySource
加载配置文件
Configuration
PropertySource(value {classpath:/jdbc.properties})
public class UserConfig {
}Scope 作用域
默认通过Bean注入IOC容器的对象都是单实例的但是可以通过Scope注解来修改 Scope(scopeName “prototype”) 代表多实例, 获取对象的时候才会创建 Scope(scopeName “singleton”) 代表单实例, IOC容器启动的时候就会创建对象
Configuration
public class MaiConfig2 {Scope(scopeName prototype)Bean(name person2)public Person person() {Person person new Person();person.setName(王五);person.setAge(30);return person;}
}Lazy 懒加载
单实例bean默认在容器启动的时候创建对象 懒加载: 容器启动不创建对象,第一次使用(获取)Bean创建对象,并初始化 Scope(scopeName singleton)LazyBean(name person2)public Person person() {System.out.println(person 添加到 IOC容器------);Person person new Person();person.setName(王五);person.setAge(30);return person;}Conditional
按照一定的条件进行判断,满足条件给容器中注册该注解可以添加到方法 / 类 中此注解需要的值是实现Condition接口的类 1.当添加到Bean上代表满足指定条件才注册该对象 2.当添加到类上代表满足条件才注册所有的bean
Import
给容器中注册组件方式
包扫描组件标志注册(Controller/Service/Repository/Component) 【自己写的】Bean【导入的第三方包里面的组件】Import【快速给容器中导入一个组件】 Import(要导入到容器中的组件)容器就会自动注册这个组件组件名默认是全类名ImportSelector 返回需要导入的组件的全类名数组ImportBeanDefinitionRegistrar 使用Spring提供的FactoryBean工厂Bean 默认获取到的是工程bean调用getObject创建的对象要获取对象Bean本身我们需要给id前面加一个
生命周期 的4种方式
通过Bean指定生命周期
Configuration
public class MainConfigOfLifeCycle {Bean(initMethod init,destroyMethod destory)public Car car(){return new Car();}
}通过接口
通过调用 InitializingBean, DisposableBean 接口来分别实现创建和销毁方法
public class Cat implements InitializingBean, DisposableBean {public Cat(){System.out.println(Cat 执行初始化方法);}Overridepublic void destroy() throws Exception {System.out.println(执行 Cat destroy方法);}Overridepublic void afterPropertiesSet() throws Exception {System.out.println(执行 Cat afterPropertiesSet方法);}
}通过注解
PostConstruct 在bean创建完成并且属性赋值完成来执行初始化方法 PerDestroy 在容器销毁bean之前通过我们进行清理工作
通过后置处理器 BeanPostProcessor
这个在上面已经介绍了接口的使用
Profile
Spring为我们提供的可以根据当前环境动态的激活和切换一系列组件的功能
加了环境标识的bean 只有这个环境被激活的时候才能注入这个组件默认是default环境写在配置类上只有是指定的环境的时候整个配置类里面的所有配置才能开始生效没有表示环境表示的bean 在任何环境下都是加载的
激活配置环境的方式:
使用命令行动态参数 -Dspring.profiles.activedev使用代码的方式
AliasFor
该注解有2个功能
给属性提供别名继承注解
注意点
1.属于隐性别名组中的每一个属性必须使用AliasFor进行注释,并且attribute必须引用相同元注解中的同一个属性 2.别名化的属性必须声明相同的返回类型 3.别名化的属性必须定义默认值 4.别名化的属性必须声明相同的默认值 5.注解必须引用合适的元注解 6.被引用的元注解必须放置在声明了AliasFor的注解上
Retention(RetentionPolicy.RUNTIME)
Target({ElementType.METHOD})
Documented
public interface AliasFor {// 属性的别名AliasFor(attribute)String value() default ;AliasFor(value)String attribute() default ;// Class? extends Annotation annotation() default Annotation.class;
}RequestMapping示例
// 两个属性互为别名代表设置哪个都可以
Target({ElementType.TYPE, ElementType.METHOD})
Retention(RetentionPolicy.RUNTIME)
Documented
Mapping
public interface RequestMapping {String name() default ;AliasFor(path)String[] value() default {};AliasFor(value)String[] path() default {};RequestMethod[] method() default {};String[] params() default {};String[] headers() default {};String[] consumes() default {};String[] produces() default {};}注解继承
像我们使用的Controller、Service、Repository都是继承的Component
Target({ElementType.TYPE})
Retention(RetentionPolicy.RUNTIME)
Documented
Component
public interface Controller {// 继承注解AliasFor(annotation Component.class)String value() default ;
}SpringBootApplication是一个组合注解里面的属性也继承到每个子注解中
Target(ElementType.TYPE)
Retention(RetentionPolicy.RUNTIME)
Documented
Inherited
SpringBootConfiguration
EnableAutoConfiguration
ComponentScan(excludeFilters { Filter(type FilterType.CUSTOM, classes TypeExcludeFilter.class),Filter(type FilterType.CUSTOM, classes AutoConfigurationExcludeFilter.class) })
public interface SpringBootApplication {AliasFor(annotation EnableAutoConfiguration.class)Class?[] exclude() default {};AliasFor(annotation EnableAutoConfiguration.class)String[] excludeName() default {};AliasFor(annotation ComponentScan.class, attribute basePackages)String[] scanBasePackages() default {};AliasFor(annotation ComponentScan.class, attribute basePackageClasses)Class?[] scanBasePackageClasses() default {};AliasFor(annotation ComponentScan.class, attribute nameGenerator)Class? extends BeanNameGenerator nameGenerator() default BeanNameGenerator.class;AliasFor(annotation Configuration.class)boolean proxyBeanMethods() default true;}
ImportResource
如果项目使用的XML来注册Bean那么可以使用该注解来导入xml文件到配置类然后就会解析当前xml文件
Configuration(proxyBeanMethods false)
ImportResource(locations classpath:spring.xml) // 自动将xml文件注入到配置类
public class UserConfig {Beanpublic User user() {return new User();}
}ConfigurationProperties
实现配置绑定有两种方式
通过 Component ConfigurationProperties通过 EnableConfigurationProperties ConfigurationProperties
两种方式实现的功能一样只不过是组件的注入地方第2种方式多应用于第三方jar包因为我们导入的jar包上面可能没有添加Component同时jar包又不可以修改所以通过EnableConfigurationProperties来添加
总结下来 EnableConfigurationProperties这个注解有两个功能第1就是注入该组件第2实现配置绑定
ConfigurationProperties
Target({ ElementType.TYPE, ElementType.METHOD })
Retention(RetentionPolicy.RUNTIME)
Documented
Indexed
public interface ConfigurationProperties {// 前缀AliasFor(prefix)String value() default ;AliasFor(value)String prefix() default ;boolean ignoreInvalidFields() default false;boolean ignoreUnknownFields() default true;}方式一
第1步需要使用Spring的功能必须注入到容器中
地2步通过ConfigurationProperties注解
Data
Component
ConfigurationProperties(prefix jia)
public class User {private String id;private String name;}方式二
第1步添加ConfigurationProperties注解
Data
ConfigurationProperties(prefix jia)
public class User {private String id;private String name;}第2步配置添加EnableConfigurationProperties
Configuration(proxyBeanMethods false)
EnableConfigurationProperties(User.class)
public class UserConfig {}
