Spring笔记-Bean基础及使用
|
0
|
Java

3217 字
|
32 分钟

Spring是什么？

Spring是一种开源轻量级框架，是为了解决企业应用程序开发复杂性而创建的，Spring致力于各层解决方案，而不仅仅于某一层的方案。Spring贯穿于表现层，业务层，持久层，Spring并不想取代那些已有的框架，而是与这些已有的进行整合。比如持久化和ORM映射，Spring只对现有的JDBC，Hibernate等技术提供支持，使之更容易使用，而不做重复的实现。

Spring的模块

  • Spring Core： 基础,可以说 Spring 其他所有的功能都需要依赖于该类库。主要提供 IoC 依赖注入功能。
  • Spring Aspects ： 该模块为与AspectJ的集成提供支持。
  • Spring AOP ：提供了面向切面的编程实现。
  • Spring JDBC : Java数据库连接。
  • Spring JMS ：Java消息服务。
  • Spring ORM : 用于支持Hibernate等ORM工具。
  • Spring Web : 为创建Web应用程序提供支持。
  • Spring Test : 提供了对 JUnit 和 TestNG 测试的支持。

Spring Bean的使用

基于xml使用

首先，新建一个Person类，注意，这个类要是一个JavaBean，有无参的默认构造函数，有私有属性及对应的getter/setter

public class Person implements Serializable {
    public Person() {
    }
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

然后在resources目录下新建个beans.xml文件，完整内容如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="person" class="com.lk.cap1.Person">
        <property name="age" value="1"></property>
        <property name="name" value="test"></property>
    </bean>
</beans>

在main方法中，调用bean

public class TestBean {
    public static void main(String[] args) {
        //把beans.xml中的类加载到容器中
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        //根据bean标签的id，从容器中去获取bean实例
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}
//输出如下
Person{name='test', age=1}

其实配置文件中还有很多参数可以配置，比如作用域singleton，配置这个bean对象是单例，还有prototype,request,session三个作用域，配置文件已经不用了，现在都基于注解，所以不多记录。

基于注解使用

Person类和上面一样，不过是多了一个两个参数的构造函数，新建MainConfig类

@Configuration用于定义配置类，可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

@Bean表示声明该方法返回的实例是受Spring管理的Bean，其有以下几个参数可供设置

  • value或name: 含义相同，为 bean 起一个名字，如果默认没有写该属性，那么就使用方法的名称为该 bean 的名称
  • autowire: 装配方式，Autowire.NO (默认设置) , Autowire.BY_NAME (根据名称), Autowire.BY_TYPE(根据类型)
  • initMethod: bean的初始化方法， 直接指定方法名称即可，不用带括号
  • destroyMethod: bean的销毁方法，在调用 IoC 容器的 close() 方法时，会执行到该属性指定的方法。不过，只是单实例的 bean 才会调用该方法，如果是多实例的情况下，不会调用该方法
@Configuration
public class MainConfig {
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}

然后在main方法中，通过AnnotationConfigApplicationContext获取到bean容器

public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        Person person = (Person) app.getBean("person");
        System.out.println(person);
}
//输出如下
Person{name='Test', age=1}

要知道IOC容器相当于一个大的map，而app.getBean(“person“)中的person就相当于key，这个key默认是config中的方法名，当然你也可以指定，如下

@Bean("CustomPerson") //如不指定，默认是方法名
public Person person() {
        return new Person("Test", 1);
}

//调用
Person person = (Person) app.getBean("CustomPerson");

bean初始化时我们可以执行指定的方法，通过initMethod参数去指定初始化方法，如下

@Bean(value = "CustomPerson",initMethod = "init")
public Person person() {
      return new Person("Test", 1);
}

然后Person类中也要加上对应的init方法

public class Person implements Serializable {
    public void init(){
        System.out.println("init person");
    } 
    //.....省略
}

再执行main方法，输出如下，可以看到在输出bean对象信息前，先执行了init方法

init person
Person{name='Test', age=1}

@ComponentScan扫描规则

我们实际项目开发中，一般都要分三层，service层、dao层、controller层，每一层都有一个对应的注解，注解于类上

  • Service层: @Service
  • Dao层: @Repository
  • Controller层: @Controller

前面我们是新建了一个MainConfig，在其中返回我们需要的方法，而这三层必然对应多个类，我们总不能一一写在MainConfig中返回，这样代码也太丑了。

ComponentScan做的事情就是告诉Spring从哪里找到bean，由你来定义哪些包需要被扫描。一旦你指定了，Spring将会将在被指定的包及其下级的包(sub packages)中寻找bean，这样的话不用你一一去定义了，只需要在MainConfig中配置好扫描规则即可。

开始使用

ComponentScan下面这部分转自 https://www.jianshu.com/p/64aac6461d5b ，不花时间再写了，和我准备写的流程完全一样，我最后补充自定义过滤器

1.创建一个配置类，在配置类上添加 @ComponentScan 注解。该注解默认会扫描该类所在的包下所有的配置类，相当于在beans.xml中的 <context:component-scan>

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class BeanConfig {

}

2.使用 ApplicationContext 的 getBeanDefinitionNames() 方法获取已经注册到容器中的 bean 的名称。

import io.mieux.config.BeanConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App02 {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(BeanConfig.class);

        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanName : beanDefinitionNames) {
            System.out.println("beanName: " + beanName);
        }
    }
}

运行效果：

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig

除了 spring 本身注册的一些 bean 之外，可以看到最后一行，已经将 BeanConfig 这个类注册进容器中了。

3.指定要扫描的包（使用@ComponentScan 的 valule 属性来配置），创建一个controller 包，并在该包下新建一个 AppController 类。

package io.mieux.controller;

import org.springframework.stereotype.Controller;

@Controller
public class AppController {
}

在类上加了@Controller注解，说明该类是一个 Component。在 BeanConfig 类中修改：

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan(value = "io.mieux.controller")
public class BeanConfig {

}

在 @ComponentScan 注解中指定了要扫描的包。

运行效果：

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appController

AppController 已经被注册进容器了。

4.excludeFilters 和 includeFilters 的使用

使用 excludeFilters 来按照规则排除某些包的扫描。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@ComponentScan(value = "io.mieux",
        excludeFilters = {@Filter(type = FilterType.ANNOTATION,
        value = {Controller.class})})
public class BeanConfig {

}

excludeFilters 的参数是一个 Filter[] 数组，然后指定 FilterType 的类型为 ANNOTATION，也就是通过注解来过滤，最后的 value 则是Controller 注解类。配置之后，在 spring 扫描的时候，就会跳过 io.mieux 包下，所有被 @Controller 注解标注的类。

使用 includeFilters 来按照规则只包含某些包的扫描。

再创建一个 service 的包，并创建一个 AppService 类，再加上一个 @Service 注解。

package io.mieux.service;

import org.springframework.stereotype.Service;

@Service
public class AppService {
}

修改 BeanConfig 类：

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@ComponentScan(value = "io.mieux", includeFilters = {@Filter(type = FilterType.ANNOTATION, classes = {Controller.class})})
public class BeanConfig {

}

运行效果：

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appController
beanName: appService

配置里面，应该是只包含 @Controller 注解的类才会被注册到容器中，为什么 @Service 注解的类也被注册了呢？这里涉及到 @ComponentScan 的一个 useDefaultFilters 属性的用法，该属性默认值为 true，也就是说 spring 默认会自动发现被 @Component、@Repository、@Service 和 @Controller 标注的类，并注册进容器中。要达到只包含某些包的扫描效果，就必须将这个默认行为给禁用掉（在 @ComponentScan 中将 useDefaultFilters 设为 false 即可）。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@ComponentScan(value = "io.mieux", 
        includeFilters = {@Filter(type = FilterType.ANNOTATION, classes = {Controller.class})},
        useDefaultFilters = false)
public class BeanConfig {

}

运行效果：

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appController

5.添加多种扫描规则

1、如果使用的 jdk8，则可以直接添加多个 @ComponentScan 来添加多个扫描规则，但是在配置类中要加上 @Configuration 注解，否则无效。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@ComponentScan(value = "io.mieux.controller")
@ComponentScan(value = "io.mieux.service")
@Configuration
public class BeanConfig {

}

2、也可以使用 @ComponentScans 来添加多个 @ComponentScan，从而实现添加多个扫描规则。同样，也需要加上 @Configuration 注解，否则无效。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.context.annotation.Configuration;

@ComponentScans(value = 
        {@ComponentScan(value = "io.mieux.controller"),
        @ComponentScan(value = "io.mieux.service")})
@Configuration
public class BeanConfig {

}

6.添加自定义过滤规则

在前面使用过 @Filter 注解，里面的 type 属性是一个 FilterType 的枚举类型：

public enum FilterType {
    ANNOTATION,
    ASSIGNABLE_TYPE,
    ASPECTJ,
    REGEX,
    CUSTOM
}

使用 CUSTOM 类型，就可以实现自定义过滤规则。

1、 首先创建一个实现 TypeFilter 接口的 CustomTypeFilter 类，并实现其 match 方法。

package io.mieux.config;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

import java.io.IOException;

public class CustomTypeFilter implements TypeFilter {
    @Override
    public boolean match(MetadataReader metadataReader,
                         MetadataReaderFactory metadataReaderFactory) throws IOException {

        // 获取当前扫描到的类的注解元数据
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 获取当前扫描到的类的元数据
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        // 获取当前扫描到的类的资源信息
        Resource resource = metadataReader.getResource();

        if (classMetadata.getClassName().contains("Co")) {
            return true;
        }

        return false;
    }
}

这里简单对扫描到的类名进行判断，如果类名包含”Service”的就符合条件，也就会注入到容器中。

2、对 BeanConfig 进行修改，指定过滤类型为 Custom 类型，并指定 value 为 CustomTypeFilter.class。

package io.mieux.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;

@ComponentScan(value = "io.mieux",
        includeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM, value = {CustomTypeFilter.class})},
        useDefaultFilters = false)
public class BeanConfig {

}

public class CustomTypeFilter implements TypeFilter {    
    @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();
        //过滤规则，类名包含service，根据自己需求调整
        if (className.contains("service")) {
            return true;
        }
        return false;
    }
}

运行效果：

beanName: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanName: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalRequiredAnnotationProcessor
beanName: org.springframework.context.annotation.internalCommonAnnotationProcessor
beanName: org.springframework.context.event.internalEventListenerProcessor
beanName: org.springframework.context.event.internalEventListenerFactory
beanName: beanConfig
beanName: appService

@Scope作用域

  • singleton：单例模式，全局有且仅有一个实例
  • prototype：原型模式，每次获取Bean的时候会有一个新的实例
  • request：request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
  • session：session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效
  • globalsession：global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义

@Scope默认值为singleton，其实常用的就singleton，单例的话要注意，如果实例中有非静态变量，那么可能会导致线程安全问题，共享资源的竞争。prototype的话，可能会频繁创建bean实例，性能差，也影响GC回收。

@Configuration
public class MainConfig {
    @Scope("singleton") //直接填写作用域，不填写直接用@Scope，默认为singleton
    @Bean(value = "CustomPerson",initMethod = "init")
    public Person person() {
        return new Person("Test", 1);
    }
}

@Lazy懒加载

如果不是懒加载的话，IOC容器启动时就会加载所有对象，而懒加载时，只有当你第一次去使用这个对象时，才会去加载，加快IOC容器启动速度，如果出现循环依赖，也可以通过@Lazy调整。

@Configuration
public class MainConfig {
    @Lazy
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}

@Condition条件注册

有时候根据业务需求不同，可能会条件性的注册一些bean，比如根据操作系统是win/linux，这个时候可以在条件里判断当前是什么操作系统。

比如我们要根据操作系统是win还是linux注册指定bean，新建一个类WinCondition,实现spring里的Condition接口的matches方法

public class WinCondition implements Condition {
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //获取IOC容器正在使用的BeanFactory
        //BeanFactory:用于从容器中获取bean
        //FactoryBean:用于注册bean到容器
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //获取当前环境变量，比如当前的操作系统信息
        Environment environment = conditionContext.getEnvironment();
        //获取操作系统名称
        String osName = environment.getProperty("os.name");
        if (osName.toLowerCase().contains("windows")) {
            return true;
        }
        return false;
    }
}

然后给需要条件的bean添加@Condition注解即可，就只有在windows操作系统下，才会注册这个bean，也可以在MainConfig上面添加@Condition注解

@Configuration
public class MainConfig {
    //在方法上加条件
    @Conditional(WinCondition.class)
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}
//在类上加条件，对所有方法进行过滤
@Conditional(WinCondition.class)
@Configuration
public class MainConfig {
    @Bean
    public Person person() {
        return new Person("Test", 1);
    }
}

@Import导入

@Import表示要导入一个或多个@Configuration类，允许从另一个配置类加载@Bean定义，也可以直接导入一个组件

第一种，直接导入一个类，但是这样没办法注入参数，使用的是导入的类的默认构造函数

@Configuration
public class Dog {
    @Bean
    public Person personA() {
        return new Person("Test", 1);
    }
}
//导入一个
@Import(Dog.class)
@Configuration
public class MainConfig {
}
//导入多个
@Import(value = {Dog.class, Cat.class})
@Configuration
public class MainConfig {
}

第二种，使用ImportBeanDefinitionRegistrar将类注入到IOC容器中，特别灵活，在registerBeanDefinitions方法里想注入哪些就注入哪些

public class DogBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        BeanDefinitionBuilder dogBean = BeanDefinitionBuilder.rootBeanDefinition(Dog.class);
        //可以通过containsBeanDefinition判断IOC容器中是否存在某个类，看自己需求
        boolean dogExist = beanDefinitionRegistry.containsBeanDefinition(Dog.class.getName());
        if(dogExist) {
          //.....
        }
        //通过BeanDefinitionRegistry注入到容器
        beanDefinitionRegistry.registerBeanDefinition("Dog", dogBean.getBeanDefinition());
    }
}
@Import(DogBeanDefinitionRegistrar.class)
@Configuration
public class MainConfig {
}

第三种，使用ImportSelector注入，只需要返回一个String[]数组，里面的内容是类名即可

public class DogImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{
                Dog.class.getName()
        };
    }
}

@Import(DogImportSelector.class)
@Configuration
public class MainConfig {
}

第四种，其实还是ImportSelector，不过是多创建了一个注解，在这个注解中@Import，然后在Config中再加上这个注解，更加灵活，Spring中的各种Starter包，都是通过EnableXXXX 注解进行开启使用，就是这个

public class DogImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{
                Dog.class.getName() //如果不使用getName，那么必须使用全路径类名"com.xxx.xx.Dog"
        };
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.TYPE)
@Import(DogImportSelector.class)
public @interface EnableDog {
}

@EnableDog
@Configuration
public class MainConfig {
}
beanjavaspring
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
															
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																

							
							
						

															
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇 

                    

                    
			        推荐文章
		            

		            

							
优雅的拷贝不同层的对象(VO,DO等)

							
							

							
Spring参数校验及通用异常信息返回

							
							

							
Spring AOP实现Redis缓存方法

							
							

							
Spring MVC使用JWT做token验证

							
							

							
docker运行springboot+haproxy+mysql+redis

							
							

							
SpringBoot 打包jar并生成docker镜像

							
							

							
Spring中实现单点Redis分布式锁

							
							

							
Spring Boot+MyBatis+Druid多数据源配置

							
							

							
Spring笔记-自动装配注解

							
							

							
Spring笔记-Bean的生命周期