十、Spring IoC注解式开发-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45372862/article/details/129331449

1 声明Bean的注解

负责声明Bean的注解，常见的包括四个：

@Component
@Controller
@Service
@Repository

@Controller、@Service、@Repository这三个注解都是@Component注解的别名。
也就是说：这四个注解的功能都一样。用哪个都可以。

只是为了增强程序的可读性，建议：

控制器类上使用：Controller
service类上使用：Service
dao类上使用：Repository

他们都是只有一个value属性。value属性用来指定bean的id，也就是bean的名字

2 Spring注解的使用

如何使用以上的注解呢？

第一步：加入aop的依赖

当加入spring-context依赖之后，会关联加入aop的依赖。

第二步：在配置文件中添加context命名空间

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

第三步：在配置文件中指定扫描的包

<!--给spring框架指定要扫描的包-->
<context:component-scan base-package="com.powernode.spring6.bean"/>

第四步：在Bean类上使用注解

package com.powernode.spring6.bean;

import org.springframework.stereotype.Component;

@Component("userBean")
public class User {
}

以上注解就相当于以下这个配置信息：

<bean id="userBean" class="com.powernode.spring6.bean.User"/>

测试

@Test
    public void testBeanComponent(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User user = applicationContext.getBean("userBean", User.class);
        System.out.println(user);
    }

注解的属性名是value，那么value是可以省略的。
如果把value属性全部省略，Bean有默认的名称：Bean类名首字母小写。

如果是多个包有两种解决方案：
第一种：在配置文件中指定多个包，用逗号隔开。
第二种：指定多个包的共同父包。

<!--多个包，使用,隔开-->
<context:component-scan base-package="com.powernode.spring6.bean, com.powernode.spring6.dao"/>
<!--多个包，也可以指定这多个包共同的父包，牺牲一部分效率-->
<context:component-scan base-package="com.powernode.spring6"/>

3 选择性实例化Bean

use-default-filters=“true” 表示：使用spring默认的规则，只要有Component、Controller、Service、Repository中的任意一个注解标注，则进行实例化。

use-default-filters=“false” 表示：不再spring默认实例化规则，即使有Component、Controller、Service、Repository这些注解标注，也不再实例化。

<!--
	 第一种解决方案：
       use-default-filters="false"
       如果这个属性是false，表示com.powernode.spring6.bean包下所有的带有声明Bean的注解全部失效。@Component @Controller @Service @Repository全部失效。
-->
<context:component-scan base-package="com.powernode.spring6.bean" use-default-filters="false">
	<!--包含-->
    <!--只有@Repository @Service被包含进来，生效-->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
</context:component-scan>

<!--
    第二种解决方案：
        use-default-filters="true"
        如果这个属性的值是true，表示com.powernode.spring6.bean下的所有的带有声明Bean的注解全部生效。

        use-default-filters="true" 默认值就是true，不用写。
-->
<context:component-scan base-package="com.powernode.spring6.bean">
    <!--排除掉-->
    <!--@Controller失效-->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

4 负责注入的注解

给Bean属性赋值需要用到这些注解：

@Value
@Autowired
@Qualifier

@Resource

1 @Value

当属性的类型是简单类型时，可以使用@Value注解进行注入。

使用@Value注解注入的话，可以用在属性上，并且可以不提供setter方法

// 使用@Value注解注入的话，可以用在属性上，并且可以不提供setter方法
@Value("com.mysql.cj.jdbc.Driver")
private String  driver;
@Value("jdbc:mysql://localhost:3306/spring6")
private String  url;
@Value("root")
private String  username;
@Value("root")
private String  password;

@Value注解也可以使用在setter方法上

private String  driver;
private String  url;
private String  username;
private String  password;
// @Value注解也可以使用在setter方法上
@Value("com.mysql.cj.jdbc.Driver")
public void setDriver(String driver) {
    this.driver = driver;
}
@Value("jdbc:mysql://localhost:3306/spring6")
public void setUrl(String url) {
    this.url = url;
}
@Value("root")
public void setUsername(String username) {
    this.username = username;
}
@Value("root")
public void setPassword(String password) {
    this.password = password;
}

@Value注解也可以用在构造方法的形参上

private String  driver;
private String  url;
private String  username;
private String  password;
// @Value注解也可以用在构造方法的形参上
public MyDataSource(@Value("com.mysql.cj.jdbc.Driver") String driver, @Value("jdbc:mysql://localhost:3306/spring6") String url, @Value("root") String username,@Value("root") String password) {
    this.driver = driver;
    this.url = url;
    this.username = username;
    this.password = password;
}

2 @Autowired与@Qualifier

@Autowired注解可以用来注入非简单类型。被翻译为：自动连线的，或者自动装配。
单独使用@Autowired注解，默认根据类型装配。【默认是byType】

OrderDao接口

package org.powernode.dao;

public interface OrderDao {
    void insert();
}

OrderDao接口的实现类

package org.powernode.dao.impl;

import org.powernode.dao.OrderDao;
import org.springframework.stereotype.Repository;

@Repository("orderDaoImplForMySQL")
public class OrderDaoImplForMySQL implements OrderDao {
    @Override
    public void insert() {
        System.out.println("MySQL数据库正在保存订单信息....");
    }
}

OrderService

package org.powernode.service;

import org.powernode.dao.OrderDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("orderService")
public class OrderService {

    // @Autowired注解使用的时候，不需要指定任何属性，直接使用
    // 根据类型byType进行自动装配
    @Autowired
    private OrderDao orderDao;

    public void generate(){
        orderDao.insert();
    }
}

配置包扫描

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

    <context:component-scan base-package="org.powernode"/>
</beans>

测试程序

@Test
    public void testAutowired(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-autowired.xml");
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
        orderService.generate();
    }

@Autowired注解默认是byType进行注入的，也就是说根据类型注入的，如果以上程序中，UserDao接口如果有多个实现类，会出现错误，错误信息中说：不能装配，UserDao这个Bean的数量大于1.

怎么解决这个问题？byName，根据名称进行装配了。
@Autowired注解和@Qualifier注解联合起来才可以根据名称进行装配，在@Qualifier注解中指定Bean名称。

package org.powernode.service;

import org.powernode.dao.OrderDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service("orderService")
public class OrderService {
    //  @Autowired和@Qualifier联合使用，可以根据名字自动装配
    @Autowired
    @Qualifier("orderDaoImplForMySQL")
    private OrderDao orderDao;

    public void generate(){
        orderDao.insert();
    }
}

@Autowired注解可以出现的位置：属性上、构造方法上、构造方法的参数上、setter方法上。

当带参数的构造方法只有一个，并且构造方法上的参数和属性能够对应上，@Autowired注解可以省略。

3 @Resource

@Resource注解也可以完成非简单类型注入。那它和@Autowired注解有什么区别？

@Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
@Autowired注解是Spring框架自己的。
@Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。
@Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。
@Resource注解用在属性上、setter方法上。
@Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。

引入依赖

Spring6+版本使用这个依赖

<dependency>
  <groupId>jakarta.annotation</groupId>
  <artifactId>jakarta.annotation-api</artifactId>
  <version>2.1.1</version>
</dependency>

StudentDao接口

package cn.powernode.dao;

public interface StudentDao {
    void deleteById();
}

StudentDao接口的实现类

package cn.powernode.dao.impl;

import cn.powernode.dao.StudentDao;
import org.springframework.stereotype.Repository;

@Repository("studentDaoImplForMySQL")
public class StudentDaoImplForMySQL implements StudentDao {
    @Override
    public void deleteById() {
        System.out.println("MySQL正在删除学生信息...");
    }
}

StudentService

package cn.powernode.service;

import cn.powernode.dao.StudentDao;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

@Service("studentService")
public class StudentService {

    @Resource(name = "studentDaoImplForMySQL")
    private StudentDao studentDao;

    /*@Resource(name = "studentDaoImplForMySQL")
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }*/

    public void deleteStudent(){
        studentDao.deleteById();
    }
}

配置包扫描

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

    <context:component-scan base-package="cn.powernode"/>
</beans>

测试程序:

@Test
public void testResource(){
     ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-resource.xml");
     StudentService studentService = applicationContext.getBean("studentService", StudentService.class);
     studentService.deleteStudent();
 }

@Resource注解：默认byName注入，没有指定name时把属性名当做name，根据name找不到时，才会byType注入。byType注入时，某种类型的Bean只能有一个。

5 全注解式开发

写一个配置类来代替配置文件。

package cn.powernode;

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

/**
 * 编写一个类代替Spring框架的配置文件
 */
@Configuration
// 组件扫描
@ComponentScan({"cn.powernode.dao", "cn.powernode.service"})
public class Spring6Config {
}

编写测试程序：不再new ClassPathXmlApplicationContext()对象了。
new AnnotationConfigApplicationContext()对象

@Test
public void testNoXML(){
    ApplicationContext applicationContext= new AnnotationConfigApplicationContext(Spring6Config.class);
    StudentService studentService = applicationContext.getBean("studentService", StudentService.class);
    studentService.deleteStudent();
}