Spring学习日记(一)

最新推荐文章于 2024-09-10 23:20:35 发布

qq_43419801

最新推荐文章于 2024-09-10 23:20:35 发布

阅读量99

点赞数

分类专栏： SSM 文章标签： spring java ioc bean

本文链接：https://blog.csdn.net/qq_43419801/article/details/112862428

版权

SSM 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Spring学习日记（一）----IoC

一、IoC容器简介

Spring IoC容器是一个管理Bean的容器。在Spring的定义中，所有的IoC容器都需要实现接口BeanFactory。

下面是BeanFactory源码：

public interface BeanFactory {
    //前缀
    String FACTORY_BEAN_PREFIX = "&";

    //多个getBean方法
    Object getBean(String var1) throws BeansException;

    <T> T getBean(String var1, Class<T> var2) throws BeansException;

    Object getBean(String var1, Object... var2) throws BeansException;

    <T> T getBean(Class<T> var1) throws BeansException;

    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;

    //是否包含Bean
    boolean containsBean(String var1);

    //是否是单例
    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;

    //是否是原型
    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;

    //是否类型匹配
    boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;

    //获取Bean类型
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;

    //获取Bean别名
    String[] getAliases(Str
                        ing var1);
}

多个getBean方法，用于按类型、名称等获取Bean；

isSingleton方法判断Bean是否单例，默认情况Bean都是单例的；

isPrototype方法与isSingleton方法相反，如果isPrototype结果为true，使用getBean时，IoC容器会返回一个新的Bean给调用者。

二、装配Bean

Spring可以使用XML或Java配置文件来装配Bean，或者使用注解扫描装配

1、通过配置文件

首先，我们定义一个POJO

public class Student {
    private Long id;
    private String name;

    public Student(Long id, String name) {
        this.id = id;
        this.name = name;
    }
	
	//get、set方法省略
	
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

然后，在bean.xml文件中装配它

<bean id="student" class="XMLComponent.Student">
        <constructor-arg name="id" value="1001"></constructor-arg>
        <constructor-arg name="name" value="xml_student"></constructor-arg>
</bean>

接下来，就可以通过getBean获取这个Bean

public class XMLComponent {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Student student = (Student)context.getBean("student");
        System.out.println(student);
    }
}

刚刚获取的Bean：

除了通过xml配置文件可以装配bean，通过Java配置文件（使用@Configuration注解）也可以装配Bean：

我们定义一个Java配置文件：

@Configuration
public class StudentConfig {
    @Bean(name="java_config_bean")
    public Student init(){
        Student student = new Student();
        student.setId(10003L);
        student.setName("java_config_name");
        return student;
    }
}

使用@Configuration注解表明类StudentConfig是一个配置文件，@Bean注解表示init方法将返回POJO装配到IoC容器中，name属性为Bean的名字（为配置将使用方法名init作为Bean的名字）

下面，我们使用getBean方法获取这个bean

public class JavaConfigComponent {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(StudentConfig.class);
        Student student = (Student)ac.getBean("java_config_bean");
        System.out.println(student);
    }
}

成功获取到Bean：

2、通过注解扫描

一个个装配Bean太麻烦，我们可以使用@Component和@ComponentScan注解进行扫描装配

注解@Component标明将被IoC容器扫描装配的类，注解中value的值为Bean的名称，如果未注明value，IoC容器将会将类名首字母小写后的类名作为Bean名称。

@Component("teacher")
public class Teacher {
    @Value("1234")
    private Long id;
    @Value("annotationScan")
    private String name;

    //省略get、set方法
    
    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

指定Bean，还需要指定何种策略去扫描装配Bean，为了让IoC容器装配该类，需要改造类AppConfig，使用注解@ComponentScan对当前包和子包进行扫描：

@Configuration
@ComponentScan
public class AppConfig {
}

这样，就可以使用getBean方法来获取装配好的Bean：

public class AnnotationScan {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);
        Teacher teacher = (Teacher)ac.getBean("teacher");
        System.out.println(teacher);
    }
}

测试一下，成功的获取到了装配的Bean：

注解@ComponentScan可以自定义扫描规则：

定义扫描的包名：

@ComponentScan( basePackages = {"cn.codeaper.*"})

定义扫描的类：

@ComponentScan( basePackageClass = {User.class})

此外，还可以加上注解@Filter定义过滤条件

使用includeFilters定义满足过滤器条件才扫描：

@ComponentScan(basePackages = "AnnotationScan",includeFilters = {@ComponentScan.Filter(classes = Service.class)})

使用exculdeFilters定义不扫描满足过滤条件的Bean：

@ComponentScan(basePackages = "AnnotationScan",excludeFilters = {@ComponentScan.Filter(classes = Service.class)})

注：在excludedFilters中的class属性指定的是Controller，Service之类的，不是具体的类。

三、依赖注入

1、注解@Autowired

有时候，Bean之间会有依赖关系，比如，人类（Person）使用餐具（Tableware）吃饭，一个Bean会使用到其它Bean，在Spring IoC容器中，称为依赖注入（DI）。

人类（Person）：

@Component("person")
public class Person {

    @Autowired
    private Tableware tableware;

    public void eat(){
        this.tableware.use();
    }

    public void setTableware(Tableware tableware){
        this.tableware = tableware;
    }
}

餐具（Tableware）接口：

public interface Tableware {
    public void use();
}

筷子（Chopsticks）实现类：

@Component("chopsticks")
public class Chopsticks implements Tableware{
    public void use() {
        System.out.println("使用筷子夹菜...");
    }
}

在人类接口中，使用注解@Autowired将餐具（Tableware）实例注入，注解@Autowired根据属性的类型找到对应的Bean进行注入，

下面我们测试一下：

@Configuration
@ComponentScan
public class AppConfig {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);
        Person person = ac.getBean(Person.class);
        person.eat();
    }
}

测试成功，我们成功的在人类（Person）调用了tableware的use方法，说明餐具（Tableware）实例成功注入：

如果此时，再为餐具（Tableware）添加一个实现类勺子（Spoon）：

@Component("spoon")
public class Spoon implements Tableware{
    public void use() {
        System.out.println("使用勺子舀汤...");
    }
}

那么IoC容器将会抛出异常：

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'DI.Tableware' available: expected single matching bean but found 2: chopsticks,spoon
	at org.springframework.beans.factory.config.DependencyDescriptor.resolveNotUnique(DependencyDescriptor.java:173)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1116)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1066)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:585)
	... 14 more

因为找到了两个类型为Tableware的bean。

注解@Autowired首先根据类型寻找，如果找到的Bean不是唯一的，将根据属性名称和Bean的名称进行匹配，如果依然不是唯一的，那么将会抛出异常。

2、消除歧义

对类使用注解@Primary，该注解将会告诉IoC容器，发现多个Bean时优先选择被这个注解标注的bean。

为勺子（Spoon）添加注解：

@Primary
@Component("spoon")
public class Spoon implements Tableware{
    public void use() {
        System.out.println("使用勺子舀汤...");
    }
}

IoC将会优先将它注入：

使用注解@Qualifier也可以消除歧义，注解@Qualifier与注解@Autowired结合使用，按照类型和名称译器寻找bean注入：

name为chopsticks类型为Tableware的Bean被注入：

四、使用属性文件

在开发应用程序时，经常需要读取配置文件。最常用的配置方法是以key=value的形式写在.properties文件中。

Spring容器还提供了一个更简单的@PropertySource来自动读取配置文件。我们只需要在@Configuration配置类上再添加一个注解：

@Component("datasource")
@PropertySource("mysql.properties") // 表示读取classpath的app.properties
public class MysqlConfig {

    @Value("${port:3306}")
    private int port;

    @Value("${database.username}")
    private String username;

    @Value("${database.password}")
    private String password;

	//get、set方法省略

    @Override
    public String toString() {
        return "MysqlConfig{" +
                "port=" + port +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

}

${port:3306}表示使用port的值，如果没有，九使用默认值3306。

测试一下，成功的读取到值：

ord;

//get、set方法省略

@Override
public String toString() {
    return "MysqlConfig{" +
            "port=" + port +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            '}';
}

}


`${port:3306}`表示使用port的值，如果没有，九使用默认值3306。

测试一下，成功的读取到值：

![image-20210117143857818](https://i-blog.csdnimg.cn/blog_migrate/f42b3c7210c00cd575340fa8c53acdd0.png)

![image-20210117143843740](https://img-blog.csdnimg.cn/img_convert/63ac570c80eeac6622b99cae8604d90d.png)



原文链接：[添加链接描述](http://www.codeaper.cn/blog/QZLMRsqblKk3)

qq_43419801

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring学习日记(一)

Spring学习日记（一）----IoC一、IoC容器简介Spring IoC容器是一个管理Bean的容器。在Spring的定义中，所有的IoC容器都需要实现接口BeanFactory。下面是BeanFactory源码：public interface BeanFactory { //前缀 String FACTORY_BEAN_PREFIX = "&"; //多个getBean方法 Object getBean(String var1) throws Be
复制链接

扫一扫

专栏目录