spring注解驱动开发(一)

Spring常用注解(绝对经典)

1、需要导入的spring框架的依赖

    
        org.springframework
        spring-context
        4.3.12.RELEASE
    

2、@Configuration

设置类为配置类

3、AnnotationConfigApplicationContext

  • 通过配置类获取上下文环境applicationContext
  • 可以通过getBeanDefinitionNames()获得配置类中配置的各类Bean
  • 也可以使用getBeanNamesForType()通过类型来获得bean的name(id)
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String str : beanDefinitionNames) {
      System.out.println(str);
    }

4、@Bean

  • 注册一个javaBean
  • 默认用方法名作为Bean的id
  • 使用AnnotationConfigApplicationContext的实例 通过getBean来获得这个Bean
@Configuration
@ComponentScan(value = "com.atguigu")
public class MainConfig {
  @Bean
  public Person person(){
    return new Person("lisi",20);
  }
}
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    Person bean = applicationContext.getBean(Person.class);
    System.out.println(bean);

5、@ComponentScan

为配置类开启组件扫描

  • 放在配置类的上方,指定扫描的包路径如
@ComponentScan(value = "com.atguigu")
  • 还可以使用excludeFilter来设置类扫描规则如包含、排除,excludeFilter需要设置为一个数组
    排除
    包含使用excludeFilter,并为其设置一个过滤数组,来指定需要过滤掉那些组件
@Configuration
@ComponentScan(value = "com.atguigu",excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,
        classes ={Controller.class,Service.class} )
})
public class MainConfig {
  @Bean
  public Person person(){
    return new Person("lisi",20);
  }
}

包含
包含使用includeFilter,包含里面需要设置使用默认规则为false

@Configuration
@ComponentScan(value = "com.atguigu",includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,
        classes ={Controller.class,Service.class} )},useDefaultFilters = false)
public class MainConfig {
  @Bean
  public Person person(){
    return new Person("lisi",20);
  }
}

还可以设置按给定类型过滤

@Configuration
@ComponentScan(value = "com.atguigu",includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,
                classes ={Controller.class,Service.class}),
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,
                classes ={BookService.class})
},useDefaultFilters = false)
public class MainConfig {
  @Bean
  public Person person(){
    return new Person("lisi",20);
  }
}

其他可以设置的过滤方式还可以有:

  • 使用FilterType.ASPECTJ按照ASPECTJ表达式
  • 使用FilterType.REGEX按照REGEX正则表达式
  • 使用FilterType.CUSTOM按照自定义规则过滤(需要实现TypeFilter接口)

自定义过滤规则

public class MyTypeFilter implements TypeFilter {
  /*
  metadataReader:读取到的当前正在扫描的类的信息
  metadataReaderFactory:可以获取到其他任何类的信息
   */

  @Override
  public 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(resource);
    System.out.println(className);
     if(className.contains("er")){
      return true;
    }
    return false;
  }
}

设置自定义规则

@Configuration
@ComponentScan(value = "com.atguigu",includeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM,
                classes = {MyTypeFilter.class})
},useDefaultFilters = false)
public class MainConfig {
  @Bean
  public Person person(){
    return new Person("lisi",20);
  }
}

测试代码

@Test
  public void testbeans() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String str : beanDefinitionNames) {
      System.out.println(str);
    }
  }

测试结果

测试规则打印内容

file [/Users/human/Desktop/Project/05SpringMVC/spring-annotation/target/classes/com/atguigu/bean/Person.class]
com.atguigu.bean.Person
file [/Users/human/Desktop/Project/05SpringMVC/spring-annotation/target/classes/com/atguigu/config/MyTypeFilter.class]
com.atguigu.config.MyTypeFilter
file [/Users/human/Desktop/Project/05SpringMVC/spring-annotation/target/classes/com/atguigu/controller/BookController.class]
com.atguigu.controller.BookController
file [/Users/human/Desktop/Project/05SpringMVC/spring-annotation/target/classes/com/atguigu/dao/BookDAO.class]
com.atguigu.dao.BookDAO
file [/Users/human/Desktop/Project/05SpringMVC/spring-annotation/target/classes/com/atguigu/service/BookService.class]
com.atguigu.service.BookService
file [/Users/human/Desktop/Project/05SpringMVC/spring-annotation/target/classes/com/atguigu/test/MainTest.class]
com.atguigu.test.MainTest

测试类打印过滤结果

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
person
myTypeFilter
bookController
bookService

6、@Controller

将类配置为Controller类

7、@Service

将类配置为service类

8、@Repository

将类配置为dao操作的类

9、@Component

将类配置为通用类组件

10、@Scope

调整bean的作用域范围,默认单实例,可以修改为多实例
Bean是默认单实例的,通过指明prototype(多实例)和singleton(单实例)属性指明是否单实例

  • prototype:多实例
  • singleton:单实例
  • request:同一次请求创建一个实例
  • session:同一个session创建一个实例
@Configuration
@ComponentScan(value = "com.atguigu")
public class MainConfig {
  //Bean是默认单实例的,通过指明prototype(多实例)和singleton(单实例)属性指明是是否单实例
  //prototype:多实例
  //singleton:单实例
  //request:同一次请求创建一个实例
  //session:同一个session创建一个实例
  @Scope("prototype")
  @Bean("person")//指定bean的自定义id
  public Person person(){
    return new Person("张三",20);
  }
}

测试

  @Test
  public void testbeans() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
	Object bean1 = applicationContext.getBean("person");
	Object bean2 = applicationContext.getBean("person");
    System.out.println(bean1==bean2);
  }

测试结果为false

11、@Lazy懒加载

实例默认在容器创建时立即加载
使用@Lazy后,当需要创建实例时才被加载

  • 不使用懒加载
    实体类构造函数
  public Person(String name, Integer age) {
    System.out.println("给容器添加Person对象");

    this.name = name;
    this.age = age;
  }

测试代码

@Test
  public void testbeans() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    System.out.println("容器已创建完成");
    //没有获取类的代码,单实际上类的实例已经被加载进容器了
  }

测试结果

给容器添加Person对象
容器已创建完成
  • 使用懒加载
@Configuration
@ComponentScan(value = "com.atguigu")
public class MainConfig {
//  @Scope("prototype")
  @Lazy
  @Bean("person")//指定bean的自定义id
  public Person person(){

    return new Person("张三",20);
  }
}

测试代码

@Test
  public void testbeans() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    System.out.println("容器已创建完成");
    Object bean1 = applicationContext.getBean("person");//这一句出现后才加载Person类

  }

测试结果

给容器添加Person对象
容器已创建完成

12、@Conditional

  • 按一定条件注册bean,满足条件就给容器注册bean,否则不注入
  • 要作为自定义条件,需要创建自定义condition类,并要实现Condition接口,并实现match方法
  • conditional不仅可以标在方法上,还可以标记在类上
//判断是否是Linux系统的条件
//要作为自定义条件,要实现Condition接口,并实现match方法
//AnnotatedTypeMetadata:注释信息
public class LinuxCondition implements Condition {
  @Override
  public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
    //判断linux洗洗
    ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
    //获取类加载器
    ClassLoader classLoader = conditionContext.getClassLoader();
    //获得当前环境信息
    Environment environment = conditionContext.getEnvironment();
    //获取到bean定义的注册类
    BeanDefinitionRegistry registry = conditionContext.getRegistry();

    String OSproperty = environment.getProperty("os.name");
    if (OSproperty.contains("Mac OS X")){
      return true;
    }

    return false;
  }
}

另一个自定义条件

public class WindowsCondition implements Condition {
  @Override
  public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
    Environment environment = conditionContext.getEnvironment();
    //获取操作系统信息
    String OSproperty = environment.getProperty("os.name");
    if (OSproperty.contains("Window")){
      return true;
    }
    return false;
  }
}

配置类信息


@Configuration
@ComponentScan(value = "com.atguigu")
public class MainConfig {
//  @Scope("prototype")
  @Lazy
  @Bean("person")//指定bean的自定义id
  public Person person(){

    return new Person("张三",20);
  }

  @Conditional({WindowsCondition.class})
  @Bean("male")
  public Person personMale(){
    return new Person("lisi",33);
  }

  @Conditional({LinuxCondition.class})
  @Bean("female")
  public Person personFemale(){
    return new Person("wanger",23);
  }
}

测试类信息

@Test
  public void testBeans() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);

    //获取ioc容器的运行环境
    ConfigurableEnvironment environment=applicationContext.getEnvironment();
    //获取操作系统名称
    String property = environment.getProperty("os.name");
    System.out.println(property);

    String[] namesForType = applicationContext.getBeanNamesForType(Person.class);
    for (String name:namesForType) {
      System.out.println(name);
    }

  }

测试结果

Mac OS X
person
female

13、给IOC容器中注册组件的5种方法

  1. 包扫描+组件类上标注注解:(@Controller,@Service,@Repository,@Component)
  2. @Bean:导入第三方包的组件
  3. @Import:快速给容器导入一个组件
    1)@Import(要导入到容器的组件),容器中就会自动注册这个逐渐,id默认是全类名
    2)ImportSelector:返回需要导入的组件的全类名数组

4.使用ImportBeanDefinitionRegistrar
5.使用Spring提供的FactoryBean(工厂bean)注册组件
1)默认获得的是工厂bean调用getObject创建的对象
2)要获取工厂bean本身,需要给id前面加一个&标识

14、@Import 快速导入一个类

使用@Import快速为配置类导入一个bean类
可以同时导入多个bean类
需要再配置类上方书写

  • 创建被导入的bean类
public class Color {
}
public class Red {
}
  • 给配置类导入该类
@Configuration
@ComponentScan(value = "com.atguigu")
@Import({Color.class, Red.class})//在这里进行快速地导入,可以是数组形式
public class MainConfig {
//  @Scope("prototype")
  @Lazy
  @Bean("person")//指定bean的自定义id
  public Person person(){

    return new Person("张三",20);
  }

  @Conditional({WindowsCondition.class})
  @Bean("male")
  public Person personMale(){
    return new Person("lisi",33);
  }

  @Conditional({LinuxCondition.class})
  @Bean("female")
  public Person personFemale(){
    return new Person("wanger",23);
  }
}

测试类代码

 AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);

  @Test
  public void testImport(){
    printBeans(applicationContext);
  }

  private void printBeans(AnnotationConfigApplicationContext applicationContext){
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String name:beanDefinitionNames) {
      System.out.println(name);
    }
  }

测试结果

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
bookController
bookDAO
bookService
com.atguigu.bean.Color
com.atguigu.bean.Red
person
female

15、ImportSelector接口导入一个类

  • ImportSelector:返回需要导入的组件的全类名数组
  • 需要实现ImportSelector接口并改写selectImports方法

创建需要被导入的类

public class Blue {
}
public class Yellow {
}

创建自己的Import类

public class MyImportSelect implements ImportSelector {
  @Override
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
    //返回值是要导入到容器中的组件全类名
    //annotationMetadata:注解信息
    return new String[]{"com.atguigu.bean.Blue", "com.atguigu.bean.Yellow"};
  }
}

在配置类中设置@Import导入的自定义类选择器

注意:@Import({Color.class, Red.class,MyImportSelect.class})

@Configuration
@ComponentScan(value = "com.atguigu")
@Import({Color.class, Red.class,MyImportSelect.class})
public class MainConfig {
//  @Scope("prototype")
  @Lazy
  @Bean("person")//指定bean的自定义id
  public Person person(){

    return new Person("张三",20);
  }

  @Conditional({WindowsCondition.class})
  @Bean("male")
  public Person personMale(){
    return new Person("lisi",33);
  }

  @Conditional({LinuxCondition.class})
  @Bean("female")
  public Person personFemale(){
    return new Person("wanger",23);
  }
}

测试代码

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);

  @Test
  public void testImport(){
    printBeans(applicationContext);
  }

  private void printBeans(AnnotationConfigApplicationContext applicationContext){
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String name:beanDefinitionNames) {
      System.out.println(name);
    }
  }

测试结果
Color,Red,Blue,Yellow都有了

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
bookController
bookDAO
bookService
com.atguigu.bean.Color
com.atguigu.bean.Red
com.atguigu.bean.Blue
com.atguigu.bean.Yellow
person
female

16、使用ImportBeanDefinitionRegistrar接口导入类

自定义导入的类定义,需要实现ImportBeanDefinitionRegistrar接口,并重写 registerBeanDefinitions方法

创建一个需要被注入的类

public class RainBow {
}

创建自定义的注册类信息类

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  //annotationMetadata:当前类的注解信息
  //beanDefinitionRegistry:beanDefinition注册类
  //把所有需要添加到容器中的bean,调用beanDefinitionRegistry.registerBeanDefinition手动注册类
  @Override
  public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
    boolean red = beanDefinitionRegistry.containsBeanDefinition("com.atguigu.bean.Red");//判断定义中是否有红色
    boolean blue = beanDefinitionRegistry.containsBeanDefinition("com.atguigu.bean.Blue");//判断定义中是否有蓝色
    if(red && blue){
      //指定bean名
      RootBeanDefinition rainbowDefinition = new RootBeanDefinition(RainBow.class);
      //注册了一个bean,并指定了一个类名(别名)
      beanDefinitionRegistry.registerBeanDefinition("rainbow", rainbowDefinition);
    }
  }
}

在配置类中进行配置
注意:@Import({Color.class, Red.class,MyImportSelect.class,MyImportBeanDefinitionRegistrar.class})

@Configuration
@ComponentScan(value = "com.atguigu")
@Import({Color.class, Red.class,MyImportSelect.class,MyImportBeanDefinitionRegistrar.class})
public class MainConfig {
//  @Scope("prototype")
  @Lazy
  @Bean("person")//指定bean的自定义id
  public Person person(){

    return new Person("张三",20);
  }

  @Conditional({WindowsCondition.class})
  @Bean("male")
  public Person personMale(){
    return new Person("lisi",33);
  }

  @Conditional({LinuxCondition.class})
  @Bean("female")
  public Person personFemale(){
    return new Person("wanger",23);
  }
}

测试类

 @Test
  public void testImport(){
    printBeans(applicationContext);
  }

  private void printBeans(AnnotationConfigApplicationContext applicationContext){
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String name:beanDefinitionNames) {
      System.out.println(name);
    }
  }

测试结果
显示了rainbow

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
bookController
bookDAO
bookService
com.atguigu.bean.Color
com.atguigu.bean.Red
com.atguigu.bean.Blue
com.atguigu.bean.Yellow
person
female
rainbow

17、使用FactoryBean接口导入类

创建自定义工厂类,实现FactoryBean接口,并改写一下方法
getObject() //返回工厂生产的类对象
getObjectType()//返回工厂生产的类类型
isSingleton() //返回单例

创建自定义工厂类
这里实现FactoryBean接口,实现三个方法,注意泛型中使用Color类


public class ColorFactory implements FactoryBean {
  //返回一个Color对象,这个对象会添加到容器中

  @Override
  public Color getObject() throws Exception {
    System.out.println("color factory generate a instance");
    return new Color();
  }

  @Override
  public Class getObjectType() {
    return Color.class;
  }


  @Override
  public boolean isSingleton() {
    //true:返回单例,在容器中保存一份
    //false:返回多份类实例,每次获取工厂bean都会创建一个新的对象
    return false;
  }
}

在配置类中定义这个类组件
注意:
@Bean
public ColorFactory colorFactoryBean(){
return new ColorFactory();
}
}

@Configuration
@ComponentScan(value = "com.atguigu")
@Import({Color.class, Red.class,MyImportSelect.class,MyImportBeanDefinitionRegistrar.class})
public class MainConfig {
//  @Scope("prototype")
  @Lazy
  @Bean("person")//指定bean的自定义id
  public Person person(){

    return new Person("张三",20);
  }

  @Conditional({WindowsCondition.class})
  @Bean("male")
  public Person personMale(){
    return new Person("lisi",33);
  }

  @Conditional({LinuxCondition.class})
  @Bean("female")
  public Person personFemale(){
    return new Person("wanger",23);
  }

  @Bean
  public ColorFactory colorFactoryBean(){
    return new ColorFactory();
  }
}

测试类

public class MainTest {
  AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);

  @Test
  public void testImport(){
    printBeans(applicationContext);

    //工厂bean获取的是调用的是getObject创建的对象(Color类)
    Object bean1 = applicationContext.getBean("colorFactoryBean");
    Object bean2 = applicationContext.getBean("colorFactoryBean");

    System.out.println(bean1);
    System.out.println(bean2.getClass());//class com.atguigu.bean.Color
    System.out.println(bean1==bean2);
  }

  private void printBeans(AnnotationConfigApplicationContext applicationContext){
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String name:beanDefinitionNames) {
      System.out.println(name);
    }
  }

测试结果

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig
bookController
bookDAO
bookService
com.atguigu.bean.Color
com.atguigu.bean.Red
com.atguigu.bean.Blue
com.atguigu.bean.Yellow
person
female
colorFactoryBean
rainbow
color factory generate a instance
color factory generate a instance
com.atguigu.bean.Color@79c97cb
class com.atguigu.bean.Color
false

你可能感兴趣的:(Java学习笔记,spring,数据库,java)