（十二）Spring之IoC注解式开发

已于 2022-11-30 13:13:19 修改
阅读量566 收藏 1
点赞数 1
分类专栏： Spring 文章标签： spring java 后端
于 2022-11-22 22:48:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45832694/article/details/127988392
版权

文章目录


Spring学习目录

上一篇：（十一）手写简单的Spring框架

下一篇：（十三）Spring之JdbcTemplate

回顾注解

注解的存在主要是为了简化XML的配置。Spring6倡导全注解开发。
我们来回顾一下：

  • 第一：注解怎么定义，注解中的属性怎么定义？
  • 第二：注解怎么使用？
  • 第三：通过反射机制怎么读取注解？

注解怎么定义，注解中的属性怎么定义？

注解使用@interface定义，注解中的属性与接口的方法的定义一样。
自定义一个注解Component

@Target(ElementType.TYPE_USE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    String value();
    //String name();
    //int[] ages();
}

元注解

该注解上面修饰的注解包括：Target注解和Retention注解，这两个注解被称为元注解。

@Target注解

@Target注解用来修饰注解可以出现的位置。只有一个属性，是一个value，且类型是一个枚举类型。
具体值：

  • ElementType.TYPE：能修饰类、接口或枚举类型
  • ElementType.FIELD：能修饰成员变量
  • ElementType.METHOD：能修饰方法
  • ElementType.PARAMETER：能修饰参数
  • ElementType.CONSTRUCTOR：能修饰构造器
  • ElementType.LOCAL_VARIABLE：能修饰局部变量
  • ElementType.ANNOTATION_TYPE：能修饰注解
  • ElementType.PACKAGE：能修饰包
  • ElementType.RECORD_COMPONENT：与记录相关，是Java语言的预览功能。
  • ElementType.TYPE_PARAMETER：类型参数，是用在泛型类型 “T” 上的，是JDK8新推出的
  • ElementType.TYPE_USE：类型的注解，表示这个注解可以在任意地方使用（如：泛型，类型转换等），是JDK8新推出的
@Retention注解

@Retention用来标注注解最终保留位置，同样只有一个属性，是一个value，且类型是一个枚举类型。
具体值：

  • RetentionPolicy.SOURCE 注解仅存在于源码中，在class字节码文件中不包含
  • RetentionPolicy.CLASS 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得
  • RetentionPolicy.RUNTIME 注解会在class字节码文件中存在，在运行时可以通过反射获取到

注解怎么使用？

使用注解的语法：

  • @注解名(属性名 = 属性值,属性名 = 属性值,属性名 = 属性值…)

使用某个注解的时候，属性名是value，value可以省略
如果属性值是一个数组，并且值只有一个，那么{}可以省略

//@Component(value = "userBean")
@Component("userBean")
public class User {
}

通过反射机制怎么读取注解？

步骤：

  • 1.通过全限定类名获取类
  • 2.判断类上面有没有这个注解
  • 3.有则获取类上的注解
  • 4.访问注解属性
public class ReflectAnnotationTest1 {
    public static void main(String[] args) throws Exception {
        //1.获取类
        Class<?> aClass = Class.forName("com.review.bean.User");
        //2.判断类上面有没有这个注解
        if (aClass.isAnnotationPresent(Component.class)) {
            //3.有则获取类上的注解
            Component annotation = aClass.getAnnotation(Component.class);
            //4.访问注解属性
            System.out.println(annotation.value());
        }
    }
}

请添加图片描述

Spring注解原理

  • 1.只知道包的名字，这个包下有多少个Bean我们不知道
  • 2.扫描这个包下所有的类
  • 3.当这个包下的类有注解的时候，实例化该类对象
  • 4.放到一个Map集合当中

还是使用之前的自定义注解Component和User类，再添加两个类，一个有Component注解，一个没有
请添加图片描述
Order类

@Component("orderBean")
public class Order {
}

Products类：

public class Products {
}

原理程序：

public class ReflectAnnotationTest2 {
    public static void main(String[] args) {
        Map<String ,Object> map = new HashMap<>();
        //1.包名字
        String packageName = "com.review.bean";
        //2.扫描程序
        //把'.'替换成'/'，正则表达式中'.'代表任意，我们需要把普通的点替换，需要加个\，在java语言中两个斜杠代表一个斜杠。
        String packagePath = packageName.replaceAll("\\.", "/");//变成 com/review/bean

        //packagePath是一个在类根路径的路径，需要通过系统类加载器加载，自动返回一个URL路径
        URL url = ClassLoader.getSystemClassLoader().getResource(packagePath);
        String path = url.getPath();//获取绝对路径

        //获取绝对路径下所有文件
        File file = new File(path);
        File[] files = file.listFiles();

        //通过流编程遍历files
        Arrays.stream(files).forEach(fileclass -> {
            try {
                //获取绝对路径类
                String className = packageName + "." + fileclass.getName().split("\\.")[0];
                //3.通过反射机制解析注解
                Class<?> aClass = Class.forName(className);
                if (aClass.isAnnotationPresent(Component.class)) {
                    Component annotation = aClass.getAnnotation(Component.class);
                    String beanId = annotation.value();
                    Object beanObj = aClass.newInstance();
                    //4.放到一个Map集合当中
                    map.put(beanId,beanObj);

                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        System.out.println(map);
    }
}

请添加图片描述

声明Bean的注解

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

  • @Component
  • @Controller
  • @Service
  • @Repository

源码如下：
@Component：

@Target(value = {ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Component {
    String value();
}

@Controller：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

@Service注解：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

@Repository：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

通过源码可以看到，@Controller、@Service、@Repository这三个注解都是@Component注解的别名。
也就是说：这四个注解的功能都一样。用哪个都可以。
只是为了增强程序的可读性，建议：

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

如果把value属性彻底去掉，spring会自动取名，并且默认名字的规律是：Bean类名首字母小写即可。

Spring注解的使用

如何使用以上的注解呢？

  • 第一步：加入aop的依赖
  • 第二步：在配置文件中添加context命名空间
  • 第三步：在配置文件中指定扫描的包
  • 第四步：在Bean类上使用注解

第一步：加入aop的依赖

在Maven项目中，当加入spring-context依赖之后，会关联加入aop的依赖。所以这一步不用做。如果不是Maven项目，则需要把jar包导进库。

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

spring.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"
       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.xml添加指定要扫描的包：

	<context:component-scan base-package="com.annotation.bean"/>

如果是多个包怎么办？有两种解决方案：

  • 第一种：在配置文件中指定多个包，用逗号隔开。
  • 第二种：指定多个包的共同父包，这种方式会牺牲一部分效率。

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

四个注解都用一下，在bean包下创建四个类

@Controller注解使用：创建User类

//@Controller 不写value的话，默认是user，就是类名首字母小写
@Controller(value = "user")
public class User {
}

@Service注解使用：创建Student类

@Service("studentBean")
public class Student {
}

@Repository使用：创建Order类

@Repository("orderBean")
public class Order {
}

@Component使用：创建Car类

@Component("carBean")
public class Car {
}

测试程序：

@Test
    public void testBean(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        //User userBean = applicationContext.getBean("userBean", User.class);
        User userBean = applicationContext.getBean("user", User.class);
        System.out.println(userBean);
        Car carBean = applicationContext.getBean("carBean", Car.class);
        System.out.println(carBean);
        Student studentBean = applicationContext.getBean("studentBean", Student.class);
        System.out.println(studentBean);
        Order orderBean = applicationContext.getBean("orderBean", Order.class);
        System.out.println(orderBean);  
    }

请添加图片描述

选择性实例化Bean

假设在某个包下有很多Bean，有的Bean上标注了Component，有的标注了Controller，有的标注了Service，有的标注了Repository，
现在由于某种特殊业务的需要，只允许其中所有的Controller参与Bean管理，其他的都不实例化。这应该怎么办呢？

需要在配置文件的context:component-scan标签加一个属性use-default-filters，默认是true

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

    • 如果是默认值或者true，想让其特定注解失效，则添加context:exclude-filter标签

      • type属性：需要失效的类型
      • expression：需要失效的全限定路径

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

    • 如果设置成false后，想让其生效需要添加一个context:include-filter标签使特定的注解生效

      • type属性：需要生效的类型

      • expression：需要生效的全限定路径

这两种方式类似于黑名单和白名单
注意：因为Component注解是其他三个注解的”老大“，所以

  • 如果是默认值或者true，让其Component失效，会连其三个注解全部失效。
  • 如果设置成false，让其Component生效则其他三个注解也全部生效

创建bean2包，创建几个类，提供无参构造方法打印测试，为了方便测试，我们写在一个类里面：

@Component
public class A {
    public A() {
        System.out.println("A的无参数构造方法执行。。。");
    }
}
@Controller
class B{
    public B() {
        System.out.println("B的无参数构造方法执行。。。");
    }
}
@Service
class C{
    public C() {
        System.out.println("C的无参数构造方法执行。。。");
    }
}
@Repository
class D{
    public D() {
        System.out.println("D的无参数构造方法执行。。。");
    }
}
@Controller
class E{
    public E() {
        System.out.println("E的无参数构造方法执行。。。");
    }
}

创建spring-choose.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"
       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>

use-default-filters="true"情况

让其@Controller失效，spring-choose.xml配置：

	<context:component-scan base-package="com.annotation.bean2">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

测试程序：因为只需要测试是否实例化，不用获取Bean

    @Test
    public void testBeanChoose(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-choose.xml");
    }

运行发现A、C、D实例化
请添加图片描述
如果把失效注解换成@Component：

	<context:component-scan base-package="com.annotation.bean2">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>

再次运行测试程序：全都不生效了
请添加图片描述

use-default-filters="false"情况

记得上面的配置要注释掉，让其@Controller失效，spring-choose.xml配置：

    <context:component-scan base-package="com.annotation.bean2" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

测试程序是同一个，再次运行：B、E实例化
在这里插入图片描述

如果把生效注解换成@Component：

    <context:component-scan base-package="com.annotation.bean2" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>

再次运行测试程序：全都生效
请添加图片描述

负责注入的注解

@Component @Controller @Service @Repository 这四个注解是用来声明Bean的，声明后这些Bean将被实例化。如何给Bean的属性赋值。给Bean属性赋值需要用到这些注解：

  • @Value
  • @Autowired
  • @Qualifier
  • @Resource

@Value

@Value注解的源码

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {
    String value();
}

只负责简单类型的注入，属性名value，用来赋值，可以声明在属性上或setter方法上或构造方法的参数上，声明在属性上可以不提供setter方法。
创建bean3包
创建spring-value.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"
       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="com.annotation.bean3"/>
</beans>

声明在属性上

在bean3包创建User1类：声明在属性上，先提供setter方法。

@Component
public class User1 {
    @Value("张三")
    private String name;
    @Value("30")
    private int age;
    
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试程序：

    @Test
    public void testByValue(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-value.xml");
        User1 user1 = applicationContext.getBean("user1", User1.class);
        System.out.println(user1);
    }

请添加图片描述
删掉setter方法，再次运行测试程序：发现声明在属性上可以不提供setter方法。
请添加图片描述

声明setter方法上

在bean3包，创建User2类：

@Component
public class User2 {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "User2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Value("李四")
    public void setName(String name) {
        this.name = name;
    }
    @Value("20")
    public void setAge(int age) {
        this.age = age;
    }
}

在上面测试程序添加：

		User2 user2 = applicationContext.getBean("user2", User2.class);
        System.out.println(user2);

请添加图片描述

声明构造方法的参数上

在bean3包下，创建User3类

@Component
public class User3 {

    private String name;

    private int age;

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

    public User3(@Value("王五")String name, @Value("25")int age) {
        this.name = name;
        this.age = age;
    }
}

在上面测试程序添加：

		User3 user3 = applicationContext.getBean("user3", User3.class);
        System.out.println(user3);

请添加图片描述

@Autowired与@Qualifier

@Autowired 与 @Qualifier：Autowired翻译为：自动连线/自动装配，可以用来注入非简单类型

  • 单独使用@Autowired注解，默认只能根据类型自动装配【默认是byType】
  • @Autowired 与 @Qualifier 联合使用可以根据名称自动装配

创建bean4包
创建spring-autowired.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"
       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="com.annotation.bean4"/>
</beans>

在bean4包下创建dao包，在dao包下创建一个OrderDao接口：

public interface OrderDao {
    void insert();
}

在dao包下创建impl包，提供一个实现类：

@Repository
public class OrderDaoImplForMysql implements OrderDao {
    @Override
    public void insert() {
        System.out.println("Mysql正在保存订单信息");
    }
}

创建service包

根据类型自动装配

@Autowired注解源码：

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

@Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。同样注解如果声明在属性上可以不提供setter方法。当带参数的构造方法只有一个，@Autowired注解可以省略。

该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

声明在属性上

在service创建一个OrderService类：先提供setter方法

@Service
public class OrderService {
    @Autowired
    private OrderDao orderDao;

    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

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

测试程序：

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

在这里插入图片描述
删掉setter方法，再次运行测试程序：发现声明在属性上可以不提供setter方法。
请添加图片描述

声明在构造方法上

修改OrderService类：

@Service
public class OrderService {
    /*@Autowired*/
    private OrderDao orderDao;
    @Autowired
    public OrderService(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

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

与上面相同的测试程序，再次运行：
请添加图片描述

声明在构造方法的参数上
@Service
public class OrderService {
    /*@Autowired*/
    private OrderDao orderDao;
    /*@Autowired*/
    public OrderService(@Autowired OrderDao orderDao) {
        this.orderDao = orderDao;
    }

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

再次运行测试程序：
请添加图片描述
当带参数的构造方法只有一个，@Autowired注解可以省略。
去掉@Autowired注解，再次运行程序：
请添加图片描述
如果加一个带参数的构造方法

@Service
public class OrderService {
    /*@Autowired*/
    private OrderDao orderDao;
    /*@Autowired*/
    public OrderService(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
    public OrderService(OrderDao orderDao,String s) {
        this.orderDao = orderDao;
    }
    public void generate(){
        orderDao.insert();
    }
}

再次运行：报错，当带参数的构造方法只能有一个，有无参构造也不行，这个可以自己测试。
请添加图片描述

声明在setter方法上
@Service
public class OrderService {
    /*@Autowired*/
    private OrderDao orderDao;
    /*@Autowired*/
    /*public OrderService(OrderDao orderDao) {
        this.orderDao = orderDao;
    }*/
    @Autowired
    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

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

再次运行：
请添加图片描述

根据名称自动装配

以上程序OrderDao接口只有一个实现类，如果是多个呢？
在impl再创建一个实现类：

@Repository
public class OrderDaoImplForOracle implements OrderDao {
    @Override
    public void insert() {
        System.out.println("Oracle正在保存订单信息");
    }
}

回到OrderService，发现报错了
在这里插入图片描述
怎么解决这个问题呢？当然要byName，根据名称进行装配了。
@Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。
@Qualifier源码

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {
    String value() default "";
}

可见与@Autowired用法差不多，只是属性名是value，表示指定Bean名称，就能更加名称自动装配了。

修改OrderService类：添加@Qualifier注解

@Service
public class OrderService {
    @Autowired
    @Qualifier("orderDaoImplForMysql")
    private OrderDao orderDao;
    public void generate(){
        orderDao.insert();
    }
}

再次运行测试程序：
请添加图片描述
如果想使用其他实现类，修改@Qualifier注解的value即可

@Service
public class OrderService {
    @Autowired
    //@Qualifier("orderDaoImplForMysql")
    @Qualifier("orderDaoImplForOracle")
    private OrderDao orderDao;
    public void generate(){
        orderDao.insert();
    }
}

再次运行测试程序：
请添加图片描述

总结

  • @Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。
  • 注解如果声明在属性上可以不提供setter方法，当带参数的构造方法只有一个，@Autowired注解可以省略。
  • @Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。

@Resource

@Resource源码

@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Resources.class)
public @interface Resource {
    String name() default "";

    String lookup() default "";

    Class<?> type() default Object.class;

    Resource.AuthenticationType authenticationType() default Resource.AuthenticationType.CONTAINER;

    boolean shareable() default true;

    String mappedName() default "";

    String description() default "";

    public static enum AuthenticationType {
        CONTAINER,
        APPLICATION;

        private AuthenticationType() {
        }
    }
}

很多属性，我们只关注name属性：用来接收Bean的名称的，未指定时默认根据属性名作为name。
@Resource注解也可以完成非简单类型注入。那它和@Autowired注解有什么区别？

  • 区别一：

    • @Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
    • @Autowired注解是Spring框架自己的。

  • 区别二：

    • @Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。
    • @Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。

  • 区别三：

    • @Resource注解用在属性上、setter方法上。
    • @Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。

@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。】
如果是spring6+版本使用这个依赖

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

如果是spring5-版本使用这个依赖

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>

创建bean5包
创建spring-resource.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"
       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="com.annotation.bean5"/>
</beans>

创建dao包
创建StudentDao接口

public interface StudentDao {
    void deleteById();
}

创建impl包
创建两个实现类：

@Repository("studentDaoMysql")
public class StudentDaoImplForMysql implements StudentDao {

    @Override
    public void deleteById() {
        System.out.println("Mysql正在删除学生信息。。。");
    }
}


@Repository("studentDaoOracle")
public class StudentDaoImplForOracle implements StudentDao {

    @Override
    public void deleteById() {
        System.out.println("Oracle正在删除学生信息。。。");
    }
}

创建service包
创建StudentService类

@Service("studentService")
public class StudentService {
    @Resource(name = "studentDaoMysql")
    
    private StudentDao studentDaoMysql;
    

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

测试程序：

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

请添加图片描述
如果把name去掉，再次运行程序：
请添加图片描述

如果把属性名改为别的

@Service("studentService")
public class StudentService {
    //@Resource(name = "studentDaoMysql")
    @Resource
    private StudentDao studentDao;
    //private StudentDao studentDaoMysql;

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

再次运行：报错，所以说，不指定name时，默认会以属性名作为name，如果再找不到Bean，会切换成通过类型byType装配，而我们又有两个实现类，所以报错。
请添加图片描述

全注解式开发

所谓的全注解开发就是不再使用spring配置文件了。需要写一个配置类来代替配置文件。
使用@Configuration注解代替

@Configuration//代表配置文件
@ComponentScan({"com.annotation.bean5"})//这里代表context:component-scan标签
public class Spring6Config {
}

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

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

请添加图片描述

忆亦何为
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Ioc 注解 依赖注入
05-26
Spring Ioc 注解 依赖注入
Spring IOC基于注解启动示例详析
08-26
主要给大家介绍了Spring IOC基于注解启动的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
十二、Spring IoC注解式开发
m0_58512767的博客
11-12 245
以上是自定义了一个注解：Component该注解上面修饰的注解包括：Target注解和Retention注解，这两个注解被称为元注解。Target注解用来设置Component注解可以出现的位置，以上代表表示Component注解只能用在类和接口上。Retention注解用来设置Component注解的保持性策略，以上代表Component注解可以被反射机制读取。是Component注解中的一个属性。该属性类型String，属性名是value。
标记接口,注解和注解处理器的前世今生
程序那些事
05-24 8349
相信大部分的开发者都用过注解，尤其是对使用过Spring的开发者来说，注解是现代Spring中不可获取的一部分。Spring从最开始的xml配置到后面的注解配置，不论是从编程习惯还是项目的构建，都对我们程序员产生了非常重要的影响。 除了使用Spring自带的注解之外，我们还可以自定义注解。然后通过AOP来对注解进行拦截从而处理相应的业务逻辑。 除了Spring之外，其实JDK本身自带注解，本文将会深入探讨注解的起源和两种不同的使用方式。
Vue + elementUI使用中总结，包括踩坑（更新中）
是日前端
11-11 2657
<el-table-column prop="reportName" label="报告名称"> <template slot-scope="scope"> <el-input v-model="scope.row.reportName" @blur="confirmData" clearable></el-input> </tem
Java注解系列之1st
BertKing的专栏
08-17 223
岁月不居，时节如流，而立之年，忽焉将至 作为Android开发者，我们经常在项目中看到注解的身影(尤其以早期的EventBus和ButterKnife为甚)，所以掌握它是非常有必要的。 Java注解 JDK1.5之后引入的注解 参考自： 注解的分类: 按照来源来分： 元注解：定义注解的注解，位于java.lang.annotation包下。 @Target @Retention @Documented @Inherited @Repeatable（1.8） 自定义注解：JDK注解，第三方库注解，.
Spring IoC注解式开发
????
03-04 1688
Spring IoC注解式开发，这部分是相当重要的，尤其是到SpringBoot的全注解式开发，在实际开发中也是使用注解的方式。
spring之IoC注解（三）负责注入的注解
qq_42338744的博客
01-01 821
IoC是控制反转，指的是①、把创建对象的权利交出去，让别人创建，②、创建之后两个对象之间关系的维护也不管了，交给Spring去管理。spring去依赖注入。这四个注解是用来声明Bean的，声明后这些Bean将被实例化。如何给Bean的属性赋值？
【Spring篇】IOC/DI注解开发
Javascript_tsj的博客
04-30 4287
三、
SpringIOC常用注解
qq_44134480的博客
01-05 1751
Spring-IOC常用注解 1.1、@Configuration: @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface Configuration { /** * Explicitly specify the name of the Spring bean definition associated with the * {@code @Co
springioc注解详解
qq_36095290的博客
12-21 823
springioc注解详解 文章目录springioc注解详解*简略核心解释一、springioc是什么？二、使用步骤1、使用注解的方式注册bean到IOC容器中2、使用@AutoWired进行自动注入 *简略核心解释 在项目中，我们都是通过xml文件进行bean或者某些属性的赋 值，其实还有另外一种注解的方式，在企业开发中使用的很多，在bean上添加 注解，可以快速的将bean注册到ioc容器。 一、springioc是什么？ IOC是一种设计思想，在Java开发中，将你设计好的对象交给容器控制，而不是显
Spring注解驱动开发——IOC的常用注解
紫罗兰与海棠的博客
01-07 1449
一、用于注解驱动的注解 @Configuration (一) 作用 它是在spring3.0版本之后加入的。此注解是spring支持注解驱动开发的一个标志。表明当前类是spring的一个配置类，作用是替代spring的applicationContext.xml。但其本质就是@Component注解，被此注解修饰的类，也会被存入spring的ioc容器。 (二) 属性 value:用于存入spring的Ioc容器中Bean的id。 (三) 本质 就是@Component注解，被此注解修饰的类，也会被存入s
Spring高级之注解驱动开发视频教程
11-05
同时，在3.x版本之后，它开始之初Rest风格的请求URL，为开发者提供了开发基于Restful访问规则的项目提供了帮助。 SpringData是一组技术合集。里面包含了JDBC，Data JPA，Data Redis，Data Mongodb，Data Rabbit，...
SpringIoC和DI注解开发.pdf
09-26
Spring IoC 和 DI 注解开发 Spring IoC 和 DI 注解开发概述 Spring IoC（Inverse of Control，控制反转）是一种软件设计模式，它将传统的控制权从应用程序转移到框架中，使得应用程序更加灵活和可扩展。DI...
JavaEE Spring IoC注解
04-16
压缩包中使用Java中的Spring框架的注解方式来实现IoC的操作
6、Spring之Bean生命周期~创建Bean（2）
sproutBoy的博客
06-10 680
【代码】6、Spring之Bean生命周期~创建Bean（2）
SpringBoot3 整合 Mybatis 完整版
最新发布
northcastle的博客
06-14 247
SpringBoot3 整合 MyBatis 的步骤详细记录
SpringMVC
qq_51866806的博客
06-08 739
SpringMvc连接、请求、响应
门面模式Api网关(SpringCloudGateway)
风止的博客
06-05 1724
当前通过Eureka、Nacos解决了服务注册和服务发现问题，使用Spring Cloud LoadBalance解决了负载均衡的需求，同时借助OpenFeign实现了远程调用。然而，现有的微服务接口都直接对外暴露，容易被外部访问。为保障对外服务的安全性，通常在服务端实现的微服务接口会带有一定的权限校验机制。由于应用拆分成多个微服务，每个微服务都需要实现权限校验逻辑，导致当逻辑需要修改时，需要在多个应用中进行修改，增加了开发人员的负担。⽐如企业管理。
springIOC注解
07-27
Spring IOC（Inversion of Control）是Spring框架的核心特性之一，它是一种通过配置和注解的方式实现对象的依赖注入。IOC容器负责管理对象的创建、组装和生命周期，并且通过依赖注入的方式将对象之间的依赖关系解耦。 在Spring中，使用注解可以方便地标识出需要被容器管理的类和它们之间的依赖关系。以下是常见的几个IOC注解： 1. @Component：用于标识一个普通的Spring组件类，让Spring容器能够自动扫描并将其注册为Bean。 2. @Service：用于标识一个服务类，通常作为业务逻辑的实现类。 3. @Repository：用于标识一个数据访问层的类，通常与数据库交互。 4. @Controller：用于标识一个控制器类，处理用户请求并返回响应。 5. @Autowired：用于自动注入依赖对象，可以用在构造方法、属性和方法上。 6. @Qualifier：结合@Autowired使用，指定注入的具体实现类。 7. @Value：用于注入属性值。 除了以上这些常用的注解外，Spring还提供了更多的注解，如@Scope、@PostConstruct、@PreDestroy等，用于控制Bean的作用域、初始化和销毁等操作。 使用IOC注解可以简化配置文件的编写，提高开发效率，并且使代码更加清晰和可维护。同时，IOC容器也为开发者提供了更大的灵活性，可以方便地进行单元测试和模块替换等操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

忆亦何为

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值