java开启注解驱动怎么做_Spring注解驱动开发

1. @Configuration和@Bean注解

/**

* 配置类等同之前的applicationContext.xml配置文件

*/

@Configuration //告诉spring这是一个配置类

public class MainConfig {

/**

* 使用注解在容器中注册bean，默认id是方法名，返回值为bean的类型

*

* @Bean的vale值可以指定生成bean的id

*/

@Bean(value = "person1")

public Person person() {

return new Person("ghw", 20);

}

}

2. @ComponentScan 包扫描

排除指定的类-Controller.class, Service.class

@ComponentScan(value = "com.ghw.springannotation", excludeFilters = {

@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})

})

public class MainConfig {

//省略

}

运行结果如图：

image.png

只包含指定的类 (因为useDefaultFilters 默认是true会扫描所有的类，所以要先改为false)

@ComponentScan(value = "com.ghw.springannotation", includeFilters = {

@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})

}, useDefaultFilters = false)

public class MainConfig {

/**

* 使用注解在容器中注册bean，默认id是方法名，返回值为bean的类型

*

* @Bean的vale值可以指定生成bean的id

*/

@Bean(value = "person1")

public Person person() {

return new Person("ghw", 20);

}

}

运行结果如图：

image.png

FilterType有多种，ANNOTATION是按照注解选择，ASSIGNABLE_TYPE是按照类型选择，@REGEX是正则表达式，@ASPECTJ是使用ASPECTJ注解，@CUSTOM是使用自定义规则

public enum FilterType {

ANNOTATION,

ASSIGNABLE_TYPE,

ASPECTJ,

REGEX,

CUSTOM;

private FilterType() {

}

}

3.@Scope @Lazy

public class MainConfig {

/**

* 使用注解在容器中注册bean，默认id是方法名，返回值为bean的类型

*

* @Bean的vale值可以指定生成bean的id

* @Scope value可取

* singleton,单实例，默认值，ioc容器启动即创建对象并放入容器

* prototype,多实例，使用的时候才去创建对象放入容器

* request,同一次请求创建一个request

* session,同一次请求创建一个session

*/

@Scope(value = "prototype")

@Lazy //懒加载，单实例的时候使用，使用的时候才去创建对象

@Bean(value = "person1")

public Person person() {

System.out.println("调用此方法");

return new Person("ghw", 20);

}

}

4. @Conditional

按照条件注册bean

创建俩个Bean

/**

* Conditional也可以放在类上，表示所有类都生效

* @return

*/

@Conditional({WindowsCondition.class})

@Bean(value = "windows")

public Person person01() {

return new Person("windows", 20);

}

@Conditional({LinuxCondition.class})

@Bean(value = "linux")

public Person person02() {

return new Person("linux", 20);

}

创建俩个Condition

LinuxCondition

package com.ghw.springannotation.condition;

import org.springframework.context.annotation.Condition;

import org.springframework.context.annotation.ConditionContext;

import org.springframework.core.env.Environment;

import org.springframework.core.type.AnnotatedTypeMetadata;

public class LinuxCondition implements Condition {

/**

* ConditionContext：判断条件使用的上下文环境

* AnnotatedTypeMetadata：注释信息

*/

@Override

public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {

Environment environment = conditionContext.getEnvironment();

String osname = environment.getProperty("os.name");

if (osname.contains("Linux")) {

return true;

}

return false;

}

}

WindowsCondition

package com.ghw.springannotation.condition;

import org.springframework.context.annotation.Condition;

import org.springframework.context.annotation.ConditionContext;

import org.springframework.core.env.Environment;

import org.springframework.core.type.AnnotatedTypeMetadata;

/**

* 判断是否windows系统

*/

public class WindowsCondition implements Condition {

/**

* ConditionContext：判断条件使用的上下文环境

* AnnotatedTypeMetadata：注释信息

*/

@Override

public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {

Environment environment = conditionContext.getEnvironment();

String osname = environment.getProperty("os.name");

if (osname.contains("Windows")) {

return true;

}

return false;

}

}

5. @Import

总结：

给容器中注册组件：

@Controller @Service @Component @Repository 自己创建的类

@Bean 第三方jar包内组件

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

在类名上面加@Import

@Import({Red.class, Green.class})

public class MainConfig {

结果如下，默认bean是全类名

信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@763d9750: startup date [Sat Aug 25 23:11:04 CST 2018]; root of context hierarchy

bean name:org.springframework.context.annotation.internalConfigurationAnnotationProcessor

bean name:org.springframework.context.annotation.internalAutowiredAnnotationProcessor

bean name:org.springframework.context.annotation.internalRequiredAnnotationProcessor

bean name:org.springframework.context.annotation.internalCommonAnnotationProcessor

bean name:org.springframework.context.event.internalEventListenerProcessor

bean name:org.springframework.context.event.internalEventListenerFactory

bean name:mainConfig

bean name:bookController

bean name:com.ghw.springannotation.importt.Red

bean name:com.ghw.springannotation.importt.Green

bean name:person1

bean name:linux

os name:Linux

Process finished with exit code 0

@ImportSelector

自定义要导入的bean类型，实现ImportSelector接口，实现方法selectImports，返回一个字符串数组，内容是要导入bean的全路径，annotationMetadata参数可以获取容器注解全部信息

package com.ghw.springannotation.importt;

import org.springframework.context.annotation.ImportSelector;

import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelect implements ImportSelector {

@Override

public String[] selectImports(AnnotationMetadata annotationMetadata) {

return new String[]{"com.ghw.springannotation.importt.Blue"};

}

}

annotationMetadata中的内容

@ImportBeanDefinitionRegistrar

实现ImportBeanDefinitionRegistrar 接口，通过参数beanDefinitionRegistry的containsBeanDefinition方法判断当前容器中是否包含某个bean，然后通过registerBeanDefinition方法注册新的bean

package com.ghw.springannotation.importt;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;

import org.springframework.beans.factory.support.RootBeanDefinition;

import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;

import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

@Override

public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {

Boolean red = beanDefinitionRegistry.containsBeanDefinition("com.ghw.springannotation.importt.Red");

Boolean green = beanDefinitionRegistry.containsBeanDefinition("com.ghw.springannotation.importt.Green");

if (red && green) {

RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);

beanDefinitionRegistry.registerBeanDefinition("rainbow", beanDefinition);

}

}

}

@Import({Red.class, Green.class, MyImportSelect.class, MyImportBeanDefinitionRegistrar.class})

public class MainConfig {

6. @FactoryBean

通过工厂Bean创建对象

package com.ghw.springannotation.factory;

import com.ghw.springannotation.importt.Color;

import org.springframework.beans.factory.FactoryBean;

/**

* Color类的工厂Bean，工厂Bean创建Color类，返回color对象，加入容器

*/

public class ColorFactoryBean implements FactoryBean {

@Override

public Color getObject() throws Exception {

System.out.println("调用getObject方法返回Color对象");

return new Color();

}

@Override

public Class> getObjectType() {

return Color.class;

}

@Override

/**

* true 单例

* false 多例

*/

public boolean isSingleton() {

return false;

}

}

在Config类中加入ColorFactoryBean的注解

@Bean

public ColorFactoryBean ColorFactoryBean() {

return new ColorFactoryBean();

}

测试方法

@Test

public void test() throws Exception {

printBeans(context);

Object bean = context.getBean("ColorFactoryBean");

Object bean2 = context.getBean("ColorFactoryBean");

Color color = (Color) bean;

System.out.println(bean == bean2);

color.print();

//取得当前环境

ConfigurableEnvironment environment = context.getEnvironment();

System.out.println("os name:" + environment.getProperty("os.name"));

}

public void printBeans(AnnotationConfigApplicationContext context) {

String[] nameForType = context.getBeanDefinitionNames();

//遍历输出注册的bean

for (String s : nameForType) {

System.out.println("bean name:" + s);

}

}

总结：

image.png

7. initMethod和destroyMethod

首先定义Car类，并编写构造方法init方法和destory方法

package com.ghw.springannotation.bean;

/**

* Bean的init和destory方法

*/

public class Car {

public Car() {

System.out.println("Car构造方法执行");

}

public void init() {

System.out.println("Car初始化方法");

}

public void destory() {

System.out.println("Car销毁方法");

}

}

在MainConfig类中添加注解，在注解上添加initMethod，destroyMethod

@Bean(initMethod = "init",destroyMethod = "destory")

public Car car() {

return new Car();

}

public void test02() {

Car car = (Car) context.getBean("car");

System.out.println(car);

context.close();

}

输出结果如下

信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@6f79caec: startup date [Sun Aug 26 23:19:52 CST 2018]; root of context hierarchy

Car构造方法执行

Car初始化方法

八月 26, 2018 11:19:52 下午 org.springframework.context.support.AbstractApplicationContext doClose

信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@6f79caec: startup date [Sun Aug 26 23:19:52 CST 2018]; root of context hierarchy

enter test02

com.ghw.springannotation.bean.Car@49d904ec

Car销毁方法

从结果可以看出容器创建的时候就执行构造方法然后执行init方法，容器关闭之后才执行test02，destory方法。此处有疑惑，正常不应该是先执行test再关闭容器。

以上是单实例的情况，如果是多实例，则会在使用bean的时候执行构造方法和初始化方法，容器关闭也不会执行销毁方法

如下图：

八月 26, 2018 11:22:27 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh

信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@6f79caec: startup date [Sun Aug 26 23:22:27 CST 2018]; root of context hierarchy

八月 26, 2018 11:22:28 下午 org.springframework.context.support.AbstractApplicationContext doClose

信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@6f79caec: startup date [Sun Aug 26 23:22:27 CST 2018]; root of context hierarchy

enter test02

Car构造方法执行

Car初始化方法

com.ghw.springannotation.bean.Car@4b5d6a01

7. InitializingBean, DisposableBean接口

功能和#6相似

package com.ghw.springannotation.bean;

import org.springframework.beans.factory.DisposableBean;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.stereotype.Component;

/**

* 测试InitializingBean和DisposableBean接口

*/

@Component

public class Cat implements InitializingBean, DisposableBean {

public Cat() {

System.out.println("Cat执行构造方法");

}

@Override

public void destroy() throws Exception {

System.out.println("Cat销毁方法");

}

@Override

public void afterPropertiesSet() throws Exception {

System.out.println("Cat初始化方法");

}

}

test方法

package com.ghw.springannotation.bean;

import com.ghw.springannotation.MainConfig;

import org.junit.Test;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class CatTest {

//获取context

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);

@Test

public void test() {

context.getBean("cat");

context.close();

}

}

结果如下：

八月 26, 2018 11:36:14 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh

信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@67117f44: startup date [Sun Aug 26 23:36:14 CST 2018]; root of context hierarchy

Cat执行构造方法

Cat初始化方法

八月 26, 2018 11:36:14 下午 org.springframework.context.support.AbstractApplicationContext doClose

信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@67117f44: startup date [Sun Aug 26 23:36:14 CST 2018]; root of context hierarchy

Cat销毁方法

8. @PostConstruct和@PreDestory

这俩个注解是JSR250中提出的

新建Dog类做测试

package com.ghw.springannotation.bean;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

/**

* 测试@PostConstruct和@PreDestory

*/

@Component

public class Dog {

public Dog() {

System.out.println("Dog构造方法执行");

}

/**

* PostConstruct注解的方法在Bean创建完成并且属性赋值之后执行

*/

@PostConstruct

public void init() {

System.out.println("Dog初始化方法");

}

/**

* PreDestroy注解的方法在容器销毁Bean之前执行

*/

@PreDestroy

public void destory() {

System.out.println("Dog销毁方法");

}

}

DogTest.java

package com.ghw.springannotation.bean;

import com.ghw.springannotation.MainConfig;

import org.junit.Test;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import static org.junit.Assert.*;

public class DogTest {

//获取context

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);

@Test

public void test() {

context.getBean("dog");

context.close();

}

}

运行结果如下：

image.png

9. BeanPostProcessor接口，Bean的后置处理器

postProcessBeforeInitialization在初始化之前执行

postProcessAfterInitialization在初始化之后执行

package com.ghw.springannotation.bean;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.config.BeanPostProcessor;

import org.springframework.stereotype.Component;

/**

* @author gaoho

*/

@Component

public class MyBeanPostProcessor implements BeanPostProcessor {

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

System.out.println("beanName:" + beanName + "bean:" + bean + "Before");

return bean;

}

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

System.out.println("beanName:" + beanName + "bean:" + bean + "After");

return bean;

}

}

执行结果如下：

beanName:dogbean:com.ghw.springannotation.bean.Dog@4e91d63f---Before

beanName:dogbean:com.ghw.springannotation.bean.Dog@4e91d63f---After

BeanPostProcessor原理：

image.png

image.png

image.png