Spring 的存储和获取Bean

文章目录

  • 获取 Spring 上下文对象的方式
  • 存储 Bean 对象的方式
    • 类注解
      • 配置扫描路径(必须)
      • @Controller(控制器存储)
      • @Service(服务)
      • @Repository(持久层)
      • @Component(工具)
      • @Configuration(项目中的一些配置)
      • 关于五大类注解
    • 方法注解
  • 获取指定的 Bean 对象的方式
    • 普通方式
    • 对象注入
      • 属性注入
      • 构造方法注入
      • Setter 注入
      • @Resource:另⼀种注入关键字
      • 总结

获取 Spring 上下文对象的方式

首先获取 Bean 对象之前都需要先获取 Spring 的上下文对象,那么获取这个对象可以有以下方式

ApplicationContext context =
		new ClassPathXmlApplicationContext("spring-config.xml");

BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

那么这两者之间有什么区别呢,现在新建两个 Bean 类运行起来后看结果:

1、ApplicationContext

Spring 的存储和获取Bean_第1张图片

2、BeanFactory

Spring 的存储和获取Bean_第2张图片

两者的运行结果是不一样的,通过 BeanFactory 实例出来的并不会将 Teacher 对象放入 Spring

ApplicationContext 和 BeanFeactory:

  1. ApplicationContext 会将 xml文件中所声明需要注册到Spring中的 Bean 一次性全部注册完成,而BeanFactory 则是在首次去获取某一个Bean 对象时才会去注册该对象
  2. ApplicationContext 比较废内存但是之后的读取会很快
  3. BeanFeactory 比较省内存但是效率较低
  4. ApplicationContext 是 BeanFeactory 的子类,ApplicationContext 还拥有独特的特性, 添加了对国际化支持、资源访问支持、以及事件传播等方面的支持

存储 Bean 对象的方式

基本的存储方式需要在 spring-config.xml 文件中去添加指定的 Bean 注册内容才行,这样就很麻烦。

类注解

配置扫描路径(必须)

首先在进行注解前需要先配置好路径,在 spring-config.xml 中添加下面的代码

<content:component-scan base-package="spring.demo">content:component-scan>

base-package中添加的是一串路径,也就是声明这个路径下的包中的 Bean 是有可能需要存入到 Spring 中的。注意只是有可能,开始的时候并没有立即注册存放到 Spring 中。

@Controller(控制器存储)

验证用户请求的数据正确性,相当于“安保系统”

Student类

import org.springframework.stereotype.Controller;

@Controller // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

启动类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring.demo.Student;

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        Student student = (Student) context.getBean("student", Student.class);
        // 使用 Bean 对象
        student.print("hello world");
    }
}

因为使用了注解后并没有指定id属性,这时需要将id属性写为类名的小驼峰形式,这是一个“约定”。

但是也有特例:

原类名如果首字母和第二个字母都是大写的话,id属性的名称就和原类名相同

@Service(服务)

编排和调度具体执行方法,相当于“客服中心”

Student类

@Service // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

@Repository(持久层)

和数据库进行交互,是一个“执行者”(DAO)

Student类

@Repository // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

@Component(工具)

主要是注解工具类

Student类

@Component // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

@Configuration(项目中的一些配置)

Student类

@Configuration // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

关于五大类注解

  1. 如果遇到同一个包中有 同名的类 那么可以在使用注解时使用例如 @Controller(value = “XXX”) 这种方式去分别,但是建议一个包中尽量不要有同名类
  2. 五大注解的关系:事实上五大注解都是基于 Component 实现的,也就是它们都是 Component 的“子类”,是对于 Component 的扩展。那么需要分出这么多类注解的原因就是让程序员看到类注解之后,就能直接了解当前类的用途

方法注解

方法注解就是在一个有返回值的方法上加上 @Bean 注解的方式,也就是说 Spring 会将有着 @Bean 注解的方法的返回值的对象存入

需要注意:

  1. @Bean 注解需要配合五大类注解使用
  2. 使用了@Bean 注解后,默认的 Bean 对象ID属性为该具有 @Bean 注解的方法名
  3. 可以使用 @Bean(name = {“XXX”})的形式去设置这个 Bean 对象的ID属性。并且这个重命名的 name 其实是⼀个数组,一个 Bean 可以有多个名字,例如 @Bean(name = {“XXX”, “XXX”})。并且 name= 是可以去掉的,例如 @Bean({“XXX”, “XXX”})
@Component
public class UserBeans {
    @Bean({"user"})
    public User getUser(){
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}
public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        User user = context.getBean("user", User.class);
        // 使用 Bean 对象
        System.out.println(user.getName());
    }
}

Spring 的存储和获取Bean_第3张图片

获取指定的 Bean 对象的方式

获取到上下文对象之后就可以通过调用该对象的 getBean方法去获取 Bean 对象

普通方式

首先常规的就是使用加载时设置的 id 属性去获取

Student student = (Student) context.getBean("student");

需要注意这种方式的返回值是 Object 类的,因此需要强转为 Bean 对象的类

第二种方式可以通过 Bean类的.class 加上 id 属性去获取

Student student = context.getBean("student", Student.class);

这样写法就比较优美

第三种方式可以直接通过 .class去获取,但是存在隐患

Student student = context.getBean(Student.class);

存在什么隐患呢,首先一个 Bean类是可以存放多个对象到 Spring 中的,也就是可以这样



那么如果还使用第三种方式就会出现,编译器不知道具体是要获取哪一个对象,就会报错

Spring 的存储和获取Bean_第4张图片

因此不建议使用这种方式

对象注入

在 Spring 中实现依赖注入的常见方式有以下 3 种:

  1. 属性注入(Field Injection);
  2. 构造方法注入(Constructor Injection);
  3. Setter 注入(Setter Injection)。

属性注入

属性注⼊是使⽤ @Autowired 实现的,例如下列代码

// UserService

@Service
public class UserService {
    public void print(){
        System.out.println("hello");
    }
}
// UserController

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void print(){
        userService.print();
    }
}
// Start

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        UserController user = context.getBean("userController", UserController.class);
        // 使用 Bean 对象
        user.print();
    }
}

Spring 的存储和获取Bean_第5张图片

首先可以看到 UserService 和 UserController 这两个类都是加了类注解的,因此在程序运行后,这两个 Bean 都是会被存放到 Spring 中。因为在 UserController 类包含了一个 UserService 对象,并且加了 @Autowired 注解,所以这个 UserService 对象就不需要 new 出来,而是会自动从 Spring 中直接获取。这就是属性注入

属性注入的优点:

​ 属性注入最大的优点就是实现和使用简单,只需要给变量上添加一个 @Autowired 注解,就可以在不 new 对象的情况下直接获得注入的对象

属性注入的缺点:

  1. 无法注入一个不可变的对象,也就是final 修饰的对象
  2. 只能适应于 IoC 容器
  3. 更容易违背单一设计原则

构造方法注入

构造方法注入是在类的构造方法中实现注入

// UserService

@Service
public class UserService {
    public void print(){
        System.out.println("hello");
    }
}
// UserController

@Controller
public class UserController {
   private UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void print(){
        userService.print();
    }
}
// Start

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        UserController user = context.getBean("userController", UserController.class);
        // 使用 Bean 对象
        user.print();
    }
}

Spring 的存储和获取Bean_第6张图片

当该类中只有一个构造方法的时候,可以省略 @Autowired 注解,但是有多个构造方法时就需要在需要注入的方法上加上 @Autowired 注解

构造方法注入的优点:

  1. 可注入不可变对象;
  2. 注入对象不会被修改;(构造方法在对象创建时只会执行一次,因此它不存在注入对象被随时(调用)修改的情况
  3. 注入对象会被完全初始化;(注入的对象在使用之前会被完全初始化
  4. 通用性更好。(可适用于任何环境,无论是 IoC 框架还是非 IoC 框架

Setter 注入

Setter 注入和属性的 Setter 方法实现类似,只不过在设置 set 方法的时候需要加上 @Autowired 注解

// UserService

@Service
public class UserService {
    public void print(){
        System.out.println("hello");
    }
}
// UserController

@Controller
public class UserController {
   	private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void print(){
        userService.print();
    }
}
// Start

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        UserController user = context.getBean("userController", UserController.class);
        // 使用 Bean 对象
        user.print();
    }
}

Spring 的存储和获取Bean_第7张图片

Setter注入的优点:

  1. 完全符合单一职责的设计原则,一个set方法只针对一个对象

Setter注入的缺点:

  1. 不能注入不可变对象;(final 修饰的对象)
  2. 注入的对象可被修改。(因为set方法的缘故,因此对象可以被随时随地修改)

@Resource:另⼀种注入关键字

@Controller
public class UserController {
    @Resource
    private UserService userService;

    public void print(){
        userService.print();
    }
}

@Autowired 和 @Resource 的区别:

  1. @Autowired 来自于 Spring,而 @Resource 来自于 JDK 的注解
  2. 相比于 @Autowired 来说,@Resource 支持更多的参数设置,例如 name 设置,根据名称获取 Bean,可以使用@Resource(name=“XXX”) 指定获取。而 @Autowired 需要配合 @Qualifier(value = “XXX”)
  3. @Resource 只能用于 Setter 注入和属性注入,不能用于构造函数注入

总结

属性注入的写法最简单,所以日常项目中使用的频率最高,但它的通用性不好;

而 Spring 官方推荐的是构造方法注入,它可以注入不可变对象,其通用性也更好。

如果是注入可变对象,那么可以考虑使用 Setter 注入

你可能感兴趣的:(Spring,spring,java)