java注解驱动开发

最新推荐文章于 2024-05-23 19:15:24 发布
最新推荐文章于 2024-05-23 19:15:24 发布
阅读量2.2k 收藏 3
点赞数
分类专栏： Springboot Spring 文章标签： spring annotation spring注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36719449/article/details/87520123
版权

1、组件注册

@Configuration&@Bean给容器中注册组件

@ComponentScan-自动扫描组件&指定扫描规则

自定义TypeFilter指定过滤规则

com.pc.Bean.Car

@Component
public class Car {

}

public class GilrFriend {

}

com.pc.Config.MyTypeFilter

@Configuration
//@ComponentScan(value={"com.pc.Bean"})
//扫描包 注册组件
@ComponentScans(value=@ComponentScan(value={"com.pc.Bean","com.pc.Controller"},
        includeFilters = {
//                @ComponentScan.Filter(type=FilterType.ANNOTATION,value=Controller.class),
                @ComponentScan.Filter(type = FilterType.CUSTOM,value = {MyTypeFilter.class})

        },
        excludeFilters = @ComponentScan.Filter(),useDefaultFilters = false))
//useDefaultFilters = false 扫描时包的时候不使用默认的过滤器 例如FilterType.ANNOTATION

//@ComponentScan  value:指定要扫描的包
//excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
//FilterType.ANNOTATION：按照注解
//FilterType.ASSIGNABLE_TYPE：按照给定的类型；
//FilterType.ASPECTJ：使用ASPECTJ表达式
//FilterType.REGEX：使用正则指定
//FilterType.CUSTOM：使用自定义规则
public class MainConfig {
    @Bean
    public GilrFriend gilrFriend(){
        return  new GilrFriend();
    }
	
	/**
	 * @Bean标注的方法创建对象的时候，方法参数的值从容器中获取
	 * @param car
	 * @return
	 */
	@Bean
	public GilrFriend gilrFriend2 (Car car){
		GilrFriend gilrFriend = new GilrFriend ();
		gilrFriend .setCar(car);
		return gilrFriend ;
	}

}

测试代码：

public class MainApp {

    public static void main(String[] args) {

//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
//		Person bean = (GilrFriend) applicationContext.getBean("gilrFried");
//		System.out.println(bean);

//        应用上下文 对比以前xml获取bean的方式。
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
        Object gilrFried = context.getBean(GilrFriend.class);
        System.out.println(gilrFried);

//        打印容器中所有的bean
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
}

@Scope设置组件作用域

@Lazy-bean懒加载

@Configuration
public class MainConfig2 {
//默认是单实例的
    /**
     * ConfigurableBeanFactory#SCOPE_PROTOTYPE
     * @see ConfigurableBeanFactory#SCOPE_SINGLETON
     * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST  request
     * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION	 sesssion
     * @return\
     * @Scope:调整作用域
     * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
     * 					每次获取的时候才会调用方法创建对象；
     * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
     * 			以后每次获取就是直接从容器（map.get()）中拿，
     * request：同一次请求创建一个实例
     * session：同一个session创建一个实例
     *
     * 懒加载：
     * 		单实例bean：默认在容器启动的时候创建对象；
     * 		懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
     *
     */
        @Bean(name="girlFriend")
        @Scope("singleton")
        @Lazy()
        public GilrFriend gilrFriend(){
            return  new GilrFriend();
        }
}

测试：

public class MainConfig2Test {

    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

    @Test
    public void testScopeAndLazy(){
        Object girlFriend = applicationContext.getBean("girlFriend");
        System.out.println(girlFriend);

    }
}

组件注册-@Conditional-按照条件注册bean

springboot底层大量使用的注解，按照一定的条件判断给容器注册bean。

/**
 * ConditionContext：判断条件能使用的上下文（环境）
 *
 * @See https://www.cnblogs.com/davidwang456/p/4199459.html
 * AnnotatedTypeMetadata:定义访问特定类型的注解，不需要加载类。主要方法有：
 * 是否有匹配的注解类型
 * boolean isAnnotated(String annotationType)
 * 获取特定类型注解的属性
 * Map<String,Object> getAnnotationAttributes(String annotationType,boolean classValuesAsString)
 */
public class MoneyCondition implements Condition {
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
//        TODO: 实现自己的逻辑，决定什么条件下注册自己的bean。本例子：有钱注册拜金女

        //1、能获取到ioc使用的beanfactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //2、获取类加载器
        ClassLoader classLoader = conditionContext.getClassLoader();
        //3、获取当前环境信息
        Environment environment = conditionContext.getEnvironment();

        BeanDefinitionRegistry registry = conditionContext.getRegistry();

        Map<String, Object> annotationAttributes = annotatedTypeMetadata.getAnnotationAttributes("org.springframework.stereotype.Service");
        System.out.println("---》"+annotatedTypeMetadata);
        System.out.println("是否包含service注解："+annotatedTypeMetadata.isAnnotated("org.springframework.stereotype.Service"));;
        try {
            Money bean = conditionContext.getBeanFactory().getBean(Money.class);
            if (bean != null) {
                return true;
            }

        } catch (NoSuchBeanDefinitionException e) {
            return false;

        }

        return false;
    }
}

com.pc.Config.MainConfig2

   /**
     * 注释该bean 则拜金女不会注入
     * @return
     */
    @Bean(name="money")
    public Money money(){
        return new Money();
    }

    /**
     * 得有钱才行  -->__--> 拜金女
     * @return
     */
    @Bean(name="拜金女")
    @Conditional(MoneyCondition.class)
    public GilrFriend gilrFriend3(){
        return  new GilrFriend("拜金女");
    }

测试结果：
在这里插入图片描述
在这里插入图片描述

组件注册-@Import-给容器中快速导入一个组件

  • 比较简单 不做详细介绍
@Configuration
@Import(Car.class)
public class MainConfig3 {
}

组件注册-@Import-使用ImportSelector

  • 示例：
//自定义逻辑返回需要导入的组件
public class CurrentImportSelector implements ImportSelector {
//    返回值，就是到导入到容器中的组件全类名
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        boolean annotated = annotationMetadata.isAnnotated("com.pc.Annotation.Register");
//        获取的是@import注解标记的类上所有其他注解
        System.out.println("---:"+annotationMetadata.getAnnotationTypes());
        if (annotated) {
            Map<String, Object> annotationAttributes = annotationMetadata.getAnnotationAttributes("com.pc.Annotation.Register");
            Boolean value = (Boolean)annotationAttributes.get("value");
            if (value) {
                return new String[]{"com.pc.Bean.Timer"};
            }
        }
        return new String[0];
    }
}

@Configuration
@Import(CurrentImportSelector.class)// 不是注册CurrentImportSelector 而是注册CurrentImportSelector返回的全类型数组
@Register(false)
//@Register 我自己定义的注解 ，true注册组件 false不注册组件
public class MainConfig3 {
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Register {
    public boolean value() default true;
}

组件注册-@Import-使用ImportBeanDefinitionRegistrar


public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

        /**
         * AnnotationMetadata：当前类的注解信息
         * BeanDefinitionRegistry:BeanDefinition注册类；
         * 把所有需要添加到容器中的bean；调用
         * 	BeanDefinitionRegistry.registerBeanDefinition手工注册进来
         */
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

            boolean definition = registry.containsBeanDefinition("com.pc.Bean.Timer");
            if(definition){
                //指定Bean定义信息；（Bean的类型，Bean。。。）
                RootBeanDefinition beanDefinition = new RootBeanDefinition(House.class);
                //注册一个Bean，指定bean名
                registry.registerBeanDefinition("house", beanDefinition);
            }
        }

}

@Configuration
@Import({CurrentImportSelector.class,MyImportBeanDefinitionRegistrar.class})
@Register(true)
//@Register 我自己定义的注解 ，true注册组件 false不注册组件
public class MainConfig3 {
}

在这里插入图片描述

组件注册-使用FactoryBean注册组件

//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

	//返回一个Color对象，这个对象会添加到容器中
	public Color getObject() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("ColorFactoryBean...getObject...");
		return new Color();
	}

	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Color.class;
	}

	//是单例？
	//true：这个bean是单实例，在容器中保存一份
	//false：多实例，每次获取都会创建一个新的bean；
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return false;
	}

}

//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

    //返回一个Color对象，这个对象会添加到容器中
    public Color getObject() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("ColorFactoryBean...getObject...");
        return new Color();
    }

    public Class<?> getObjectType() {
        // TODO Auto-generated method stub
        return Color.class;
    }

    //是单例？
    //true：这个bean是单实例，在容器中保存一份
    //false：多实例，每次获取都会创建一个新的bean；
    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return false;
    }

}

public class MainConfig3 {
    @Bean
    public ColorFactoryBean colorFactoryBean (){
        return  new ColorFactoryBean();
    }
}

在这里插入图片描述

组件注册小结

/**
 * 给容器中注册组件；
 * 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
 * 2）、@Bean[导入的第三方包里面的组件]
 * 3）、@Import[快速给容器中导入一个组件]
 * 		1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
 * 		2）、ImportSelector:返回需要导入的组件的全类名数组；
 * 		3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
 * 4）、使用Spring提供的 FactoryBean（工厂Bean）;
 * 		1）、默认获取到的是工厂bean调用getObject创建的对象
 * 		2）、要获取工厂Bean本身，我们需要给id前面加一个&
 * 			&colorFactoryBean
 */

生命周期

生命周期-@Bean指定初始化和销毁方法

/**
 * bean的生命周期：
 * 		bean创建---初始化----销毁的过程
 * 容器管理bean的生命周期；
 * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
 * 
 * 构造（对象创建）
 * 		单实例：在容器启动的时候创建对象
 * 		多实例：在每次获取的时候创建对象\
 * 
 * BeanPostProcessor.postProcessBeforeInitialization
 * 初始化：
 * 		对象创建完成，并赋值好，调用初始化方法。。。
 * BeanPostProcessor.postProcessAfterInitialization
 * 销毁：
 * 		单实例：容器关闭的时候
 * 		多实例：容器不会管理这个bean；容器不会调用销毁方法；
 * 
 * 
 * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
 * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
 * 
 * BeanPostProcessor原理
 * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
 * initializeBean
 * {
 * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 *}
 * 
 * 
 * 
 * 1）、指定初始化和销毁方法；
 * 		通过@Bean指定init-method和destroy-method；
 * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
 * 				DisposableBean（定义销毁逻辑）;
 * 3）、可以使用JSR250；
 * 		@PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
 * 		@PreDestroy：在容器销毁bean之前通知我们进行清理工作
 * 4）、BeanPostProcessor【interface】：bean的后置处理器；
 * 		在bean初始化前后进行一些处理工作；
 * 		postProcessBeforeInitialization:在初始化之前工作
 * 		postProcessAfterInitialization:在初始化之后工作
 * 
 * Spring底层对 BeanPostProcessor 的使用；
 * 		bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
 *
 */

BeanPostProcessor 后置处理器

@Component
public class MyBeanPostProcess implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println(s+"  MyBeanPostProcess初始化之前....");
        return o;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println(s+"  MyBeanPostProcess初始化之后");
        return o;
    }
}


@Configuration
//@Import({CurrentImportSelector.class,MyImportBeanDefinitionRegistrar.class})
//@Register(true)
@ComponentScan("com.pc")
//@Register 我自己定义的注解 ，true注册组件 false不注册组件
public class MainConfig3 {
    @Bean
    public ColorFactoryBean colorFactoryBean (){
        return  new ColorFactoryBean();
    }

    @Bean(initMethod="init",destroyMethod = "destory")
    public Sky sky (){
        return  new Sky();
    }
}

测试

  @Test
    public void testLifeStyle () {
        applicationContext.getBean("sky");
//        容器关闭 销毁对象
        applicationContext.close();
    }
}

init-method PostConstruct postProcessBeforeInitialization 执行顺序：
spring初始化顺序

属性赋值

属性赋值-@Value赋值

属性赋值-@PropertySource加载外部配置文件

在这里插入图片描述

    @Test
    public void testImport () {
         /*
         * 属性文件中的值在运行时会放入到运行环境变量中
         */
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        System.out.println(environment.getProperty("companyName"));//pcgroup
        System.out.println(environment.getProperty("location"));//zhongguoguangzhou
    }

@Configuration
@PropertySource("company.properties")
public class MainConfig4 {

    @Bean
    public Company company (){
        return  new Company();
    }

}

company.properties：

companyName=pcgroup
location=zhongguoguangzhou

自动装配-@Autowired&@Qualifier&@Primary

自动装配-@Resource&@Inject

@Resources（JSR250）
@Inject（JSR330，需要导入javax.inject）

自动装配-方法、构造器位置的自动装配

自动装配-Aware注入Spring底层组件

省略…
记录下 EmbeddedValueResolverAware（解析字符串中的占位符）

@Component
public class EmbeddedValueResolverAwarImpl implements EmbeddedValueResolverAware {

    StringValueResolver resolver;
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.resolver = resolver;
    }

    /**
     * 将占位符替换为属性文件中的值
     */
    public void parse() {
        System.out.println(resolver.resolveStringValue("公司名：${companyName} 地址：${location}"));
    }
}

自动装配-Aware注入Spring底层原理

自动装配-@Profile原理

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {

	/**
	 * The set of profiles for which the annotated component should be registered.
	 */
	String[] value();

}

class ProfileCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		if (context.getEnvironment() != null) {
			MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
			if (attrs != null) {
				for (Object value : attrs.get("value")) {
					if (context.getEnvironment().acceptsProfiles(((String[]) value))) {
						return true;
					}
				}
				return false;
			}
		}
		return true;
	}

}
Spirits、
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
@Import注解使用
m0_55806905的博客
11-21 1535
@Import注解的使用
Java注解开发
m0_53151031的博客
01-19 5140
一、自定义注解 二、
Java注解全面总结
最新发布
2301_79098686的博客
05-23 1124
小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！程序员代码面试指南 IT名企算法与数据结构题目最优解这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点， 本书选取将近200道真实出现过的经典代码面试题，帮助广“大程序员的面试准备做到万无一失。“刷”完本书后，你就是“题王”!!必看视频！
@Import注解
m0_57001006的博客
05-03 109
比如有的时候我们某个类被加载到容器中的时, 如果此时需要加载其他一些类到容器中, 那么就可以使用@Import注解。可以看到@Import注解中有一个Class[], 这个数组其实就是我们要添加到容器中的组件的类的对象。@Import注解不仅仅是可以加载自定义类到容器中, 还可以加载第三方jar包中的类到容器中。
java注解开发
进击的豌豆的博客
07-06 450
Java注解是附加在代码中的一些元信息，用于一些工具在编译、加载class、运行时进行解析和使用，起到说明、配置的功能。注解相关类都包含在包中。元注解用于修饰其他的注解 @Retention：定义注解的保留策略 @Documented：指定被修饰的该Annotation可以被javadoc工具提取成文档. @Inherited：指定被修饰的Annotation将具有继承性 2.3 注解的生命周期@Retention @Retention的3个生命周期 @Retention作用是定义被它所注解的注解保留多久
Spring注解驱动开发1
08-03
本文将深入探讨Spring的注解驱动开发，特别是`@Configuration`和`@Bean`这两个关键注解，以及如何通过Maven来构建一个Spring注解驱动的项目。 首先，让我们创建一个Maven项目，名为`spring-annotation`，并引入`...
Spring注解驱动开发.pdf
08-22
Spring注解驱动开发.pdf
Spring注解驱动开发.xmind
06-26
Spring注解驱动开发.xmind
通俗易懂的Spring注解驱动开发教程（含配套资料）
06-14
《Spring注解驱动开发》是一套帮助我们深入了解Spring原理机制的教程。现今SpringBoot.SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解.原理，比如@Conditional.@Import.@...
Spring注解驱动开发实战-springMVC
02-16
综上所述，Spring MVC的注解驱动开发为我们提供了强大的功能，可以轻松地进行ServletContext组件的注册、自定义框架行为以及处理异步请求。通过熟练掌握这些知识点，我们可以构建出高效、灵活的Web应用。同时，不断...
@Import注解详解
热门推荐
weixin_45453628的博客
04-17 2万+
@Import注解详解
@Import注解使用详解
2301_76607156的博客
03-29 1151
*** 可以导入的一个或多个 @Configuration 类* @Import的功能与 xml 中的 标签等效允许导入 @Configuration 类 、ImportSelector 和 ImportBeanDefinitionRegistrar 的实现 以及导入普通类（4.2版本开始支持；类似 AnnotationConfigApplicationContext#register(java.lang.Class)* 可以在类级别声明或作为元注释。
Spring注解驱动开发
03-28
《Spring注解驱动开发》是一套帮助我们深入了解Spring原理机制的教程； 现今SpringBoot、SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解、原理，比如@Conditional、@Import、@EnableXXX等。如果掌握这些底层原理、注解，那么我们对这些高层框架就能做到高度定制，使用的游刃有余；
Spring注解驱动
从基础到源码解析的学习记录
11-08 492
文章目录一、组件注册1、@Scope设置组件作用域2、@Lazy懒加载3、@Conditional按照条件加载bean4、@Import为容器添加组件1）@Import2）@ImprotSelector3）@ImprotBeanDefinitionRegistrar 一、组件注册 1、@Scope设置组件作用域 prototype：多例，ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象。 singleton：单例（默认值），ioc容器启动会调用方法创建对象方到容器中。每
java开启注解驱动怎么做_Spring注解驱动开发
weixin_39571219的博客
02-28 140
1. @Configuration和@Bean注解/*** 配置类等同之前的applicationContext.xml配置文件*/@Configuration //告诉spring这是一个配置类public class MainConfig {/*** 使用注解在容器中注册bean，默认id是方法名，返回值为bean的类型** @Bean的vale值可以指定生成bean的id*/@Bean(va...
Spring注解驱动开发（一）
越努力越幸运的博客
01-10 7705
Spring注解驱动开发（一）简介-注解驱动开发组件注册-`@Configuration`&amp;`@Bean`给容器中注册组件组件注册-`@ComponentScan`-自动扫描组件&amp;指定扫描规则组件注册-自定义TypeFilter指定过滤规则组件注册-`@Scope`-设置组件作用域 简介-注解驱动开发 当我们还在使用Spring、SpringMVC、Mybatis三大框架来整合开发...
【Java】Spring注解驱动开发
雨下一整晚real的博客
08-31 348
一、配置注解 首先进行一个注解案例的开发：创建数据库，然后创建JdbcTemplate对象，对数据库进行插入数据的操作。 一、创建数据库对象 create database spring_ioc; use spring_ioc; create table account{ id int primary key auto_increment, name varchar(50), money double(7,2), } 二、创建一个Maven工程，导入下面的依赖jar包 <dependen
"Spring注解驱动开发笔记：组件注册与@Configuration详解
Spring注解驱动开发是一种使用注解来驱动Spring框架进行开发的方式。本文整理于csdn博主 "让优秀成为你的习惯" 的笔记，主要涉及组件注册和@Configuration注解。 在传统的Spring开发中，我们需要在XML配置文件中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值