当前位置: 首页 > news >正文

第四章:Spring上

第四章:Spring上

4.1:Spring简介

  1. Spring概述

    官网地址:https://spring.io/

    • Spring是最受欢迎的企业级的java应用程序开发框架,数以百万的来自世界各地的开发人员使用Spring框架来创建性能好、易于测试、可重用的代码。
    • Spring框架是一个开源的Java平台,它最初是由Rod Johnson编写的,并且于2003年5月首次在Apache 2.0许可下发布。
    • Spring是轻量级的框架,其基础版本只有2MB左右的大小。
    • Spring框架的核心特性是可以用于开发任何Java应用程序,但是在Java EE平台上构建web应用程序是需要扩展的。Spring框架的目标是使J2EE开发变得更容易使用,通过启用基于POJO编程模型来促进良好的编程实践。
  2. Spring家族
    在这里插入图片描述

  3. Spring Framework

    Spring基础框架,可以视为Spring基础设施,基本上任何其他Spring项目都是以Spring Framework为基础的。

    • Spring Framework特性

      1. 非入侵式

        ​ 使用Spring Framework开发应用程序是,Spring对应用程序本身的结构影响非常小。对领域模型可以做到零污染,对功能性组件也只需要使用几个简单的注解进行标记,完全不会破坏原有结构,反而能将组件结构进一步简化。这就使得基于Spring Framework开发应用程序时结构清晰、简洁优雅。

      2. 控制反转

        IOC————Inversion of Control,翻转资源获取方向。把自己创建资源、向环境索取资源变成环境资源准备好,我们享受资源注入。

      3. 面向切面编程

        AOP————Aspect Oriented Programming,在不修改资源代码的基础上增强代码功能。

      4. 容器

        Spring IOC是一个容器,因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理,替程序屏蔽了组件创建过程中的大量细节,极大的降低了使用门槛,大幅度提高了开发效率。

      5. 组件化

        Spring实现了使用简单的组件配置组合成一个复杂的应用。在Spring中可以使用XMLJava注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。

      6. 声明式

        ​ 很多以前需要编写代码才能实现的功能,现在只需要声明需求即可由框架代为实现。

      7. 一站式

        ​ 在IOCAOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库,而且Spring旗下的项目已经覆盖了广泛领域,很多方面的功能性需求可以在Spring Framework的基础上全部使用Spring来实现。

    • Spring Framework五大功能模块

      功能模块功能介绍
      Core Container核心容器,在Spring环境下使用任何功能都必须基于IOC容器
      AOP & Aspects面向切面编程
      Testing提供了对JunitTestNG测试框架的整合
      Data Access/ Integration提供了对数据访问/集成的功能
      Spring MVC提供了面向Web应用程序的集成功能

4.2:IOC

  1. IOC容器

    • IOC思想

      IOCInversion of Control,翻译过来是反转控制

      1. 获取资源的传统方式

        ​ 在应用程序中的组件需要获取资源时,传统的方式是组件主动的从容器中获取所需要的资源,在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式,增加了学习成本,同时降低了开发效率。

      2. 反转控制方式获取资源

        ​ 反转控制的思想完全颠覆了应用程序组件获取资源的传统方式:反转了资源的获取方向——改由容器主动的将资源推动给需要的组件,开发人员不需要知道容器是如何创建资源对象的,只需要提供接收资源的方式即可,极大的降低了学习成本,提高了开发的效率。这种行为也称为查找的被动形式。

      3. DI

        DIDependency Injection,翻译过来是依赖注入

        DIIOC的另一种表述方式:即组件以一些预先定义好的方式接收来自于容器的资源注入,相对于IOC而言,这种表述更直接。

      IOC就是一种反转控制的思想,而DI是对IOC的一种具体实现。

    • IOC容器在spring中的实现

      SpringIOC容器就是IOC思想的一个落地的产品实现。IOC容器中管理的组件也叫作bean。在创建bean之前,首先需要创建IOC容器。Spring提供了IOC容器的两种实现方式:

      1. BeanFactory

        ​ 这是IOC容器的基本实现,是Spring内部使用的接口。面向Spring本身,不提供给开发人员使用。

      2. ApplicationContext

        BeanFactory的子接口,提供了更多高级特性。面向Spring的使用者,几乎所有场合都使用ApplicationContext而不是底层的BeanFactory

      3. ApplicationContext的主要实现类
        在这里插入图片描述

      类型名简介
      ClassPathXmlApplicationContext通过读取类路径下的XML格式的配置文件创建IOC容器对象
      FileSystemXmlApplicationContext通过文件系统读取XML格式的配置文件创建IOC容器对象
      ConfigurableApplicationContextApplicationContext的子接口,包含一些扩展方法refresh()close(),让ApplicationContext具有启动、关闭和刷新上下文的能力
      WebApplicationContext专门为Web应用准备,基于Web环境创建IOC容器对象,并将对象引入存入ServletContext域中
  2. 基于XML管理bean

    • 实验一:入门案例

      1. 创建模块

        创建一个新的模块,spring_helloworld_07

      2. 引入依赖

        <packaging>jar</packaging><dependencies><!-- 基于Maven依赖传递性,导入spring-context依赖即可导入当前所需所有jar包 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.1</version></dependency><!-- junit测试 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency>
        </dependencies>
        
      3. 创建类:HelloWorld

        package com.wang.pojo;public class HelloWorld {public void sayHello() {System.out.println("Hello, spring");}
        }
        
      4. 创建spring的配置文件
        在这里插入图片描述

        <!--bean: 配置一个bean对象,将对象交给IOC容器管理id: bean的唯一标识,不能重复class: 设置bean对象所对应的类型
        -->
        <bean id="helloworld" class="com.wang.pojo.HelloWorld"></bean>
        
      5. 测试

        @Test
        public void test() {// 获取IOC容器ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");// 获取IOC容器中的beanHelloWorld helloworld = (HelloWorld)ioc.getBean("helloworld");helloworld.sayHello();
        }
        

在这里插入图片描述

  • 实验二:获取bean

    创建一个新的模块,spring_ioc_xml_08,并引入spring_helloworld_07模块pom.xmljar包。创建一个Student实体类。

    package com.wang.pojo;public class Student {private Integer sid;private String name;private Integer age;private String gender;// 如下省略空参构造、全参构造、get/set方法、toString方法
    }
    
    <!-- 创建spring-ioc.xml配置文件配置一个bean对象 -->
    <bean id="studentOne" class="com.wang.pojo.Student"></bean>
    
    1. 根据id获取

      由于id属性指定了bean的唯一标识,所以根据bean标签的id属性可以精确获取到一个组件对象。

    2. 根据类型获取

      // 当根据类型获取bean时,要求IOC容器中指定类型的bean有且只能有一个// 若没有任何一个类型匹配的bean,此时抛出异常:NoSuchBeanDefinitionException// 若有多个类型匹配的bean,此时抛出异常:NoUniqueBeanDefinitionException
      @Test
      public void testIOC() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");Student student = ioc.getBean(Student.class);System.out.println(student);
      }
      
    3. 根据id和类型

      // 如果组件实现了接口,根据接口类型可以获取bean,但是要求bean唯一
      @Test
      public void testIOC() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");Student student = ioc.getBean("studentOne", Student.class);// 其中Student实现了Perso接口,且只有唯一的Student类实现了Person接口// Person  person = ioc.getBean(Person.class);System.out.println(person);
      }
      

      ​ 根据类型来获取bean时,在满足bean唯一性的前提下,其实只是看:对象 instanceof 指定的类型的返回结果,只要返回结果为true就可以认定为为和类型匹配,能够获取到。

  • 实验三:依赖注入值setter注入

    <bean id="studentTwo" class="com.wang.pojo.Student"><!--property: 通过成员变量的set方法进行赋值name:设置需要赋值的属性名(和set方法有关)value:设置为属性所赋的值--><property name="sid" value="1001"></property><property name="name" value="张三"></property><property name="age" value="23"></property><property name="gender" value=""></property>
    </bean>
    
    @Test
    public void testDI() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");Student student = ioc.getBean("studentTwo", Student.class);System.out.println(student);
    }
    
  • 实验四:依赖注入之构造器注入

    <!-- constructor-arg标签属性name: 指定参数名index: 指定参数所在位置的索引(从0开始)
    -->
    <bean id="studentThree" class="com.wang.pojo.Student"><constructor-arg value="1002"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value=""></constructor-arg><constructor-arg value="24"></constructor-arg>
    </bean>
    
    @Test
    public void testDI() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");Student student = ioc.getBean("studentThree", Student.class);System.out.println(student);
    }
    
  • 实验五:特殊值处理

    1. 字面量赋值

      <!-- 使用value属性给bean的属性赋值时,Spring会把value属性的值看做字面量 -->
      <property name="name" value="张三"></property>
      
    2. null

      <property name="gender"><null/></property>
      
    3. xml实体

      <!-- value属性值为<王五> -->
      <property name="name" value="&lt;王五&gt;"></property>
      
    4. CDATA

      <!--CDATA中的C代表Character,是文本、字符的含义、CDATA就表示纯文本数据。XML解析器看到CDATA节就知道这里是纯文本,就不会当作XML标签或属性来解析,所以CDATA节中写什么符号都随意
      -->
      <property name="name"><value><![CDATA[<王五>]]></value>
      </property>
      
  • 实验六:为类类型属性值赋值

    1. 创建一个Clazz

      package com.wang.pojo;public class Clazz {private Integer cid;private String cname;// 如下省略空参构造、全参构造、get/set方法、toString方法
      }
      
    2. Stduent中添加一个属性

      private Clazz clazz;
      
    3. 方式一:引用外部以声明的bean

      <bean id="studentFive" class="com.wang.pojo.Student"><property name="sid" value="1004"></property><property name="name" value="赵六"></property><property name="age" value="26"></property><property name="gender" value=""></property><!-- ref:引用IOC容器中的某个bean的id --><property name="clazz" ref="clazzOne"></property>
      </bean><bean id="clazzOne" class="com.wang.pojo.Clazz"><property name="cid" value="1111"></property><property name="cname" value="最强王者班"></property>
      </bean>
      
    4. 方式二:级联属性赋值

      <bean id="studentFive" class="com.wang.pojo.Student"><property name="sid" value="1004"></property><property name="name" value="赵六"></property><property name="age" value="26"></property><property name="gender" value=""></property><!-- ref:引用IOC容器中的某个bean的id --><property name="clazz" ref="clazzOne"></property><!-- 级联的方式,要保证提前为clazz属性赋值或者实例化 --><property name="clazz.cid" value="2222"></property><property name="clazz.cname" value="远大前程班"></property>
      </bean>
      
    5. 方式三:内部bean

      <bean id="studentFive" class="com.wang.pojo.Student"><property name="sid" value="1004"></property><property name="name" value="赵六"></property><property name="age" value="26"></property><property name="gender" value=""></property><property name="clazz"><!-- 内部bean,只能在当前bean的内部使用,不能直接通过IOC容器获取 --><bean id="clazzInner" class="com.wang.pojo.Clazz"><property name="cid" value="2222"></property><property name="cname" value="远大前程班"></property></bean></property>
      </bean>
      
  • 实验七:为数组类型属性赋值

    1. Student类添加一个属性

      private String[] hobby;
      
    2. 配置bean

      <bean id="studentFive" class="com.wang.pojo.Student"><property name="sid" value="1004"></property><property name="name" value="赵六"></property><property name="age" value="26"></property><property name="gender" value=""></property><property name="hobby"><array><value>抽烟</value><value>喝酒</value><value>烫头</value></array></property>
      </bean>
      
  • 实验八:为集合类型属性赋值

    1. List集合类型属性赋值

      • Clazz类中添加一个students属性

        private List<Student> students;
        
      • 方式一:在内部配置bean

        <bean id="clazzOne" class="com.wang.pojo.Clazz"><property name="cid" value="1111"></property><property name="cname" value="最强王者班"></property><property name="students"><list><ref bean="studentOne"></ref><ref bean="studentTwo"></ref><ref bean="studentThree"></ref></list></property>
        </bean>
        
      • 方式二:在外部配置bean

        <bean id="clazzOne" class="com.wang.pojo.Clazz"><property name="cid" value="1111"></property><property name="cname" value="最强王者班"></property><property name="students" ref="studentList"></property>
        </bean><!-- 配置一个集合类型额bean,需要使用util的约束 -->
        <util:list id="studentList"><ref bean="studentOne"></ref><ref bean="studentTwo"></ref><ref bean="studentThree"></ref>
        </util:list>
        
    2. Map集合类型属性赋值

      • 创建Teacher

        package com.wang.pojo;public class Teacher {private Integer tid;private String tname;
        }
        
      • Student类中添加一个属性

        private Map<String, Teacher> teacherMap;
        
      • 方式一:在内部配置bean

        <bean id="studentFive" class="com.wang.pojo.Student"><property name="sid" value="1004"></property><property name="name" value="赵六"></property><property name="age" value="26"></property><property name="gender" value=""></property><property name="teacherMap"><map><entry key="10086" value-ref="teacherOne"></entry><entry key="10010" value-ref="teacherTwo"></entry></map></property>
        </bean><bean id="teacherOne" class="com.wang.pojo.Teacher"><property name="tid" value="10086"></property><property name="tname" value="大宝"></property>
        </bean>
        <bean id="teacherTwo" class="com.wang.pojo.Teacher"><property name="tid" value="10010"></property><property name="tname" value="小宝"></property>
        </bean>
        
      • 方式二:在外部配置bean

        <bean id="studentFive" class="com.wang.pojo.Student"><property name="sid" value="1004"></property><property name="name" value="赵六"></property><property name="age" value="26"></property><property name="gender" value=""></property><property name="teacherMap" ref="studentMap"></property>
        </bean><util:map id="studentMap"><entry key="10086" value-ref="teacherOne"></entry><entry key="10010" value-ref="teacherTwo"></entry>
        </util:map>
        
  • 实验九:p命名空间

    ​ 引入p命名空间后,可以通过以下方式为bean的各个属性赋值。

    <bean id="studentSix" class="com.wang.pojo.Student"p:sid="1005" p:name="小明" p:teacherMap-ref="studentMap"></bean>
    
  • 实验十:引入外部属性文件

    1. 加入依赖

      <!-- MySQL驱动 -->
      <dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.16</version>
      </dependency>
      <!-- 数据源 -->
      <dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.0.31</version>
      </dependency>
      
    2. 创建外部文件jdbc.properties

      jdbc.driver=com.mysql.cj.jdbc.Driver
      jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
      jdbc.username=root
      jdbc.password=abc123
      
    3. 创建spring-datasource.xml并引入外部文件

      <!-- 引入jdbc.properties, 之后可以通过${key}的方式访问value-->
      <context:property-placeholder location="jdbc.properties" ></context:property-placeholder>
      
    4. 配置bean

      <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driver}"></property><property name="url" value="${jdbc.url}"></property><property name="username" value="${jdbc.username}"></property><property name="password" value="${jdbc.password}"></property>
      </bean>
      
    5. 测试,新建DataSourceTest.java文件

      @Test
      public void testDataSource() throws SQLException {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-datasource.xml");DruidDataSource dataSource = ioc.getBean(DruidDataSource.class);System.out.println(dataSource.getConnection());
      }
      
  • 实验十一:bean的作用域

    Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围,各取值含义参加下表:

    取值含义创建对象的时机
    singleton(默认)IOC容器中,这个bean的对象始终为单实例IOC容器初始化时
    prototype这个beanIOC容器中有多个实例获取bean

    如果是在WebApplicationContext环境下还会有另外两个作用域(但不常用):

    取值含义
    request在一个请求范围内有效
    session在一个会话范围内有效
    <!-- 创建spring-scope.xml配置文件配置一个bean对象 -->
    <bean id="student" class="com.wang.pojo.Student" scope="prototype"><property name="sid" value="1001"></property><property name="name" value="张三"></property>
    </bean>
    
    @Test
    public void testScope() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-scope.xml");Student student1 = ioc.getBean(Student.class);Student student2 = ioc.getBean(Student.class);System.out.println(student1 == student2); // false
    }
    
  • 实验十二:bean生命周期

    1. 具体的生命周期过程

      • 实例化:bean对象创建(调用无参构造器)。
      • 依赖注入:给bean对象设置属性。
      • 后置处理器的postProcessBeforeInitializationbean对象初始化之前操作(由bean的后置处理器负责)。
      • 初始化,需要通过beaninit-method:对象的初始化(需要配置bean时指定初始化方法)。
      • 后置处理器的postProcessAfterInitializationbean对象初始化之后操作(由bean的后置处理器负责)。
      • IOC容器关闭时销毁,需要通过beandestroy-method属性指定销毁的方法:bean对象销毁(需在配置bean时指定销毁方法)。
    2. 注意:

      • bean的作用域为单例时,生命周期的前三个步骤会在获取IOC容器时执行。
      • bean的作用域为多例时,生命周期的前三个步骤会在获取bean时执行。
    3. 创建User

      package com.wang.pojo;public class User {private Integer id;private String username;private String password;private Integer age;// 如下省略空参构造、全参构造、get/set方法、toString方法// 空参构造和这一个set方法按下面方式改动即可,其他的不变public User() {System.out.println("生命周期1:实例化");}public void setId(Integer id) {System.out.println("生命周期2:依赖注入");this.id = id;}public void initMethod() {System.out.println("生命周期3:初始化");}public void destroyMethod() {System.out.println("生命周期4:销毁");}
      }
      
    4. 创建spring-lifecyc.xml配置文件配置bean对象

      <bean id="user" class="com.wang.pojo.User" init-method="initMethod" destroy-method="destroyMethod"><property name="id" value="1"></property><property name="username" value="admin"></property><property name="password" value="123456"></property><property name="age" value="23"></property>
      </bean>
      
    5. bean的后置处理器

      bean的后置处理器会在生命周期的初始化前后添加额外的操作,需要实现BeanPostProcessor接口,且配置到IOC容器中,需要注意的是,bean后置处理器不是单独针对某一个bean生效,而是针对IOC容器中所有bean都会执行。

      package com.wang.process;public class MyBeanPostProcessor implements BeanPostProcessor {// 此方法在bean的生命周期初始化之前执行@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("MyBeanPostProcessor--->后置处理器postProcessBeforeInitialization");return bean;}// 此方法在bean的生命周期初始化之后执行@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("MyBeanPostProcessor--->前置处理器postProcessAfterInitialization");return bean;}
      }
      
      <bean id="myBeanPostProcessor" class="com.wang.process.MyBeanPostProcessor"></bean>
      
    6. 测试

      @Test
      public void test() {ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");User user = ioc.getBean(User.class);System.out.println(user);ioc.close();
      }
      
  • 实验十三:FactoryBean

    1. 简介

      FactoryBeanspring提供的一种整合第三方框架的常用机制。和普通的bean不同,配置一个FactoryBean类型的bean,在获取bean的时候得到的并不是class属性中配置的这个类的对象,而是getObject()方法的返回值。通过这种机制,Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来,只把最简洁的使用界面展示给我们。

      package org.springframework.beans.factory;public interface FactoryBean<T> {String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";@NullableT getObject() throws Exception;@NullableClass<?> getObjectType();default boolean isSingleton() {return true;}
      }
      
    2. 创建类UserFactoryBean

      package com.wang.factory;public class UserFactoryBean implements FactoryBean<User> {@Overridepublic User getObject() throws Exception {return new User();}@Overridepublic Class<?> getObjectType() {return User.class;}
      }
      
    3. 配置bean

      <bean class="com.wang.factory.UserFactoryBean"></bean>
      
    4. 测试

      @Test
      public void testFactoryBean() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-factory.xml");User user = ioc.getBean(User.class);System.out.println(user);
      }
      
  • 实验十四:基于xml的自动装配

    自动装配:根据指定的策略,在IOC容器中匹配某一个bean,自动为指定的bean中所依赖的类类型或接口类型属性赋值。

    1. 场景模拟

      • dao层:

        package com.wang.dao;public interface UserDao {void saveUser();
        }
        
        package com.wang.dao.impl;public class UserDaoImpl implements UserDao {@Overridepublic void saveUser() {System.out.println("保存成功");}
        }
        
      • service层:

        package com.wang.service;public interface UserService {void saveUser();
        }
        
        package com.wang.service.impl;public class UserServiceImpl implements UserService {private UserDao userDao;public UserDao getUserDao() {return userDao;}public void setUserDao(UserDao userDao) {this.userDao = userDao;}@Overridepublic void saveUser() {userDao.saveUser();}
        }
        
      • controller层:

        package com.wang.controller;public class UserController{private UserService userService;public void setUserService(UserService userService){this.userService = userService;}public void saveUser() {userService.saveUser();}
        }
        
      • 配置bean:手动配置

        <!-- 创建spring-autowire-xml.xml配置文件配置bean对象  -->
        <bean id="userController" class="com.wang.controller.UserController"><property name="userService" ref="userService"></property>
        </bean><bean id="userService" class="com.wang.service.impl.UserServiceImpl"><property name="userDao" ref="userDao"></property>
        </bean><bean id="userDao" class="com.wang.dao.impl.UserDaoImpl"></bean>
        
      • 测试

        @Test
        public void testAutowire() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-autowire-xml.xml");UserController userController = ioc.getBean(UserController.class);userController.saveUser();
        }
        
    2. 使用byType方式自动装配

      <!--自动装配的策略:1. no, default: 表示不装配,即bean中的属性不会自动匹配某个bean为属性值,此时属性使用默认值2. byType:根据要赋值的属性的类型,在IOC容器中匹配某个bean,为属性赋值注意:1. 若通过类型没有找到任何一个类型匹配的bean,此时不装配,属性使用默认值。2. 若通过类型找到了多个类型匹配的bean,此时会抛出异常: NoUniqueBeanDefinitionException。
      -->
      <bean id="userController" class="com.wang.controller.UserController" autowire="byType"></bean>
      <bean id="userService" class="com.wang.service.impl.UserServiceImpl" autowire="byType"></bean>
      <bean id="userDao" class="com.wang.dao.impl.UserDaoImpl"></bean>
      
    3. 使用byName方式自动装配

      <!--byName:将要赋值的属性的属性名作为bean的id在IOC容器中匹配某个bean,为属性赋值。当类型匹配的bean有多个时,此时可以使用byName实现自动装配
      -->
      <bean id="userController" class="com.wang.controller.UserController" autowire="byName"></bean>
      <bean id="userService" class="com.wang.service.impl.UserServiceImpl" autowire="byName"></bean>
      <bean id="userDao" class="com.wang.dao.impl.UserDaoImpl"></bean>
      
  1. 基于注解管理bean

    • 实验一:标记与扫苗

      1. 注解

        ​ 和XML配置文件一样,注解本身并不能执行,注解本身仅仅只是做一个标记,具体的功能是框架检测到注解标记的位置,然后针对这个位置按照注解标记的功能来执行具体操作。

        ​ 本质上:所有一切的操作都是Java代码来完成的,XML和注解只是告诉框架中的Java代码如何执行。

      2. 扫描

        Spring为了知道程序员在哪些地方标记了什么注解,就需要通过扫描的方式,来进行检测。然后跟注解进行后续操作。

      3. 新建模块

        ​ 创建一个新的模块,spring_ioc_annotation_09,并引入下面的jar包。

        <packaging>jar</packaging><dependencies><!-- 基于Maven依赖传递性,导入spring-context依赖即可导入当前所需所有jar包 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.1</version></dependency><!-- junit测试 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency>
        </dependencies>
        
      4. 标识组件的常用注解

        • @Component:将类标识为普通组件。
        • @Repository:将类标识为持久层组件。
        • @Service:将类标识为业务层组件。
        • @Controller:将类标识为持久层组件。

        ​ 通过源码我们得知:@Repository@Service@Controller这三个注解只是在@Component注解的基础上起了三个新名字。对于Spring使用IOC容器管理这些组件来说没有区别。所以@Repository@Service@Controller这三个注解只是给开发人员看的,让我们能够便于分辨组件的作用。

      5. 创建组件

        • dao层:

          package com.wang.dao;public interface UserDao {
          }
          
          package com.wang.dao.impl;@Repository
          public class UserDaoImpl implements UserDao {
          }
          
        • service层:

          package com.wang.service;public interface UserService {
          }
          
          package com.wang.service.impl;@Service
          public class UserServiceImpl implements UserService {
          }
          
        • controller层:

          package com.wang.controller;@Controller
          public class UserController {
          }
          
      6. 扫描组件

        • 情况一:最基本的扫描方式

          <!-- 创建spring-ioc-annotation.xml配置文件-->
          <context:component-scan base-package="com.wang"></context:component-scan>
          
        • 情况二:指定要排除的组件

          <!--context:exclude-filter: 排除扫描type: 设置排除扫描的方式annotation: 根据注解的类型进行排除, expression需要设置排除的注解的全类名assignable: 根据类的类型进行排除, expression需要设置排除的类的全类名
          -->
          <context:component-scan base-package="com.wang" use-default-filters="false"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
          <!-- <context:exclude-filter type="assignable" expression="com.wang.controller.UserController"/>-->
          </context:component-scan>
          
        • 情况三:仅扫描指定组件

          <!--context:include-filter: 包含扫描注意: 需要在context:component-scan标签中设置use-default-filters="false"use-default-filters: 默认为true, 设置的包下所有的类是否都需要扫描
          -->
          <context:component-scan base-package="com.wang" use-default-filters="false"><context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
          </context:component-scan>
          
      7. 测试

        @Test
        public void test() {ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");UserController userController = ioc.getBean(UserController.class);System.out.println(userController);UserService userService = ioc.getBean(UserService.class);System.out.println(userService);UserDao userDao = ioc.getBean(UserDao.class);System.out.println(userDao);
        }
        
      8. 组件所对应的beanid

        ​ 通过注解+扫描所配置的beanid,默认值为类的小驼峰,即类名的首字母为小写的结果。可以通过标识组件的注解的value属性值设置bean的自定义的id

    • 实验二:基于注解的自动装配

      1. 场景模拟

        • dao层:

          void saveUse();
          
          @Override
          public void saveUse() {System.out.println("保存成功");
          }
          
        • service层:

          void saveUser();
          
          @Autowired
          private UserDao userDao;@Override
          public void saveUser() {userDao.saveUse();
          }
          
        • controller层:

          @Autowired
          private UserService userService;//    @Autowired
          //    public UserController(UserService userService) {
          //        this.userService = userService;
          //    }//    @Autowired
          //    public void setUserService(UserService userService) {
          //        this.userService = userService;
          //    }public void saveUser() {userService.saveUser();
          }
          
      2. Autowired注解能够标识的位置

        • 标识在成员变量上,此时不需要设置成员变量的set方法。
        • 标识在set方法上。
        • 标识在为当前成员变量赋值的有参构造上。
      3. Autowired注解的原理

        • 默认通过byType的方式,在IOC容器中通过类型匹配某个bean为属性赋值。
        • 若有多个类型匹配的bean,此时会自动转换为byName的方式实现自动装配的效果。
        • byTypebyName的方式都无法实现自动装配,即IOC容器中有多个类型匹配的bean且这些beanid要赋值的属性的属性名都不一致,此时抛异常:NoUniqueBeanDefinitionException
        • 此时可以在要赋值的属性上,添加一个注解@Qualifier,通过该注解的value属性值,指定某个beanid,将这个bean为属性赋值。
      4. Autowired注解的注意事项

        ​ 若IOC容器中没有任何一个类型匹配的bean,此时抛出异常:NoSuchBeanDefinitionException。在@Autowired注解中有个属性required,默认值为true,要求必须完成自动装配,可以将required设置为false,此时能装配则装配,无法装配则使用属性的默认值。

相关文章:

第四章:Spring上

第四章&#xff1a;Spring上 4.1&#xff1a;Spring简介 Spring概述 官网地址&#xff1a;https://spring.io/。 Spring是最受欢迎的企业级的java应用程序开发框架&#xff0c;数以百万的来自世界各地的开发人员使用Spring框架来创建性能好、易于测试、可重用的代码。Spring框…...

【时频分析,非线性中频】非线性STFT在瞬时频率估计中的应用(Matlab代码实现)

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…...

MTK平台关机流程和原因(二)

&#xff08;1&#xff09;ShutdownThread 从上一篇可以看到&#xff0c;最终会调用此类的shutdown以及reboot等函数&#xff0c;我们来看一下这些函数的实现。 &#xff08;A&#xff09;被调用函数 //frameworks/base/services/core/java/com/android/server/power/Shutdo…...

【Python】pyqt6入门到入土系列,非常详细...

前言 嗨喽&#xff0c;大家好呀~这里是爱看美女的茜茜呐 一、什么是PyQt6? 简单介绍一下PyQt6 1、基础简介 PyQt6 Digia 公司的 Qt 程序的 Python 中间件。Qt库是最强大的GUI库之一。 PyQt6的官网&#xff1a;www.riverbankcomputing.co.uk/news。 PyQt6是由Riverbank Co…...

TCP socket编程

一、服务端代码 #encoding utf -8 #导入socket库 from socket import * #等待客户端来连接&#xff0c;主机地址为0.0.0.0表示绑定本机所有网络接口ip地址 IP 0.0.0.0 #端口号 PORT 50000 #定义一次从socket缓存区最多读入512个字节数据 BUFLEN 512 #实例化一个socket编程…...

HTTP——一、了解Web及网络基础

HTTP 一、使用HTTP协议访问Web二、HTTP的诞生1、为知识共享而规划Web2、Web成长时代3、驻足不前的HTTP 三、网络基础TCP/IP1、TCP/IP协议族2、TCP/IP的分层管理3、TCP/IP 通信传输流 四、与HTTP关系密切的协议&#xff1a;IP、TCP和DNS1、负责传输的 IP 协议2、确保可靠性的TCP…...

[论文笔记] chatgpt系列 2.6 DeepSpeed-chat 数据集

一、FT数据集 & Reward model数据集 Deepspeed-chat 源代码的数据集: Dahoas/rm-static: 这是一个用于强化学习的静态环境数据集,包含了一个机器人在一个固定环境中的运动轨迹。该数据集旨在用于评估强化学习算法在静态环境下的表现。 Dahoas/full-hh-rlhf: 这是一个用于…...

探究SAM和眼球追踪技术在自动医学图像分割的应用(2023+GazeSAM: What You See is What You Segment)

摘要&#xff1a; 本研究探讨眼动追踪技术与SAM的潜力&#xff0c;以设计一个协同的人机交互系统&#xff0c;自动化医学图像分割。提出了GazeSAM系统&#xff0c;使放射科医生能够在图像诊断过程中通过简单地查看感兴趣的区域来收集分割掩模。该系统跟踪放射科医生的眼球运动…...

excle中的条件求和SUMIF

问题&#xff1a;将每一行中红色文字的前一个值累计求和到境外总数这一列 使用的公式 自制单元格的格式计算公式&#xff1a;ctrlf3打开格式管理&#xff0c;创建如下公式&#xff0c;其中24是表示获取文字颜色 由于sumif只能直接与第二参数条件比较&#xff0c;所以先使用IF(公…...

python-网络爬虫.Request

Request python中requests库使用方法详解&#xff1a; 一简介&#xff1a; Requests 是Python语言编写&#xff0c;基于urllib&#xff0c; 采用Apache2 Licensed开源协议的 HTTP 库。 与urllib相比&#xff0c;Requests更加方便&#xff0c;处理URL资源特别流畅。 可以节约我…...

时序预测 | MATLAB实现GRNN广义回归神经网络时间序列预测(多指标,多图)

时序预测 | MATLAB实现GRNN广义回归神经网络时间序列预测(多指标,多图) 目录 时序预测 | MATLAB实现GRNN广义回归神经网络时间序列预测(多指标,多图)效果一览基本介绍程序设计参考资料效果一览 基本介绍 1.MATLAB实现GRNN广义回归神经网络时间序列预测(完整源码和数据) …...

如何看待低级爬虫与高级爬虫?

爬虫之所以分为高级和低级&#xff0c;主要是基于其功能、复杂性和灵活性的差异。根据我总结大概有下面几点原因&#xff1a; 功能和复杂性&#xff1a;高级爬虫通常提供更多功能和扩展性&#xff0c;包括处理复杂页面结构、模拟用户操作、解析和清洗数据等。它们解决了开发者…...

3.分支与循环

一、分支结构 1.概念 一个 CPP 程序默认是按照代码书写顺序&#xff0c;从上到下依次执行下来的。但是&#xff0c;有时我们需要选择性的执行某些语句&#xff0c;来实现更加复杂的逻辑&#xff0c;这时候就需要分支结构语句的功能来实现。选择合适的分支语句可以显著提高程序…...

面试之多线程案例(四)

1.单例模式 单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时&#xff0c;为了防止频繁地创建对象使得内存飙升&#xff0c;单例模式可以让程序仅在内存中创建一个对象&#xff0c;让所有需要调用的地方都共享这一单例对象。…...

抄写Linux源码(Day1:获取并运行 Linux0.11)

Day1&#xff1a;获取并运行 Linux0.11 参考资料&#xff1a;https://zhuanlan.zhihu.com/p/438577225 这是我参考的一个别人写的 Linux0.11 解读&#xff1a;https://github.com/dibingfa/flash-linux0.11-talk 我获取 Linux-0.11 源码的链接&#xff1a;https://github.com/…...

大数据_Hadoop_Parquet数据格式详解

之前有面试官问到了parquet的数据格式&#xff0c;下面对这种格式做一个详细的解读。 参考链接 &#xff1a; 列存储格式Parquet浅析 - 简书 Parquet 文件结构与优势_parquet文件_KK架构的博客-CSDN博客 Parquet文件格式解析_parquet.block.size_davidfantasy的博客-CSDN博…...

Docker的安装和部署

目录 一、Docker的安装部署 &#xff08;1&#xff09;关闭防火墙 &#xff08;2&#xff09;关闭selinux &#xff08;3&#xff09;安装docker引擎 &#xff08;4&#xff09;启动docker &#xff08;5&#xff09;设置docker自启动 &#xff08;6&#xff09;测试doc…...

FPGA项目实现:秒表设计

文章目录 项目要求项目设计 项目要求 设计一个时钟秒表&#xff0c;共六个数码管&#xff0c;前两位显示分钟&#xff0c;中间两位显示时间秒&#xff0c;后两位显示毫秒的高两位&#xff0c;可以通过按键来开始、暂停以及重新开始秒表的计数。 项目设计 为完成此项目共设计…...

Postgresql源码(109)并行框架实例与分析

1 PostgreSQL并行参数 系统参数 系统总worker限制&#xff1a;max_worker_processes 默认8 系统总并发限制&#xff1a;max_parallel_workers 默认8 单Query限制&#xff1a;max_parallel_workers_per_gather 默认2 表参数限制&#xff1a;parallel_workers alter table tbl …...

ES派生类的prototype方法中,不能访问super的解决方案

1 下面的B.prototype.compile方法中&#xff0c;无法访问super class A {compile() {console.log(A)} }class B extends A {compile() {super.compile()console.log(B)} }B.prototype.compile function() {super.compile() // 报错&#xff0c;不可以在此处使用superconsole.…...

idea大量爆红问题解决

问题描述 在学习和工作中&#xff0c;idea是程序员不可缺少的一个工具&#xff0c;但是突然在有些时候就会出现大量爆红的问题&#xff0c;发现无法跳转&#xff0c;无论是关机重启或者是替换root都无法解决 就是如上所展示的问题&#xff0c;但是程序依然可以启动。 问题解决…...

从WWDC看苹果产品发展的规律

WWDC 是苹果公司一年一度面向全球开发者的盛会&#xff0c;其主题演讲展现了苹果在产品设计、技术路线、用户体验和生态系统构建上的核心理念与演进脉络。我们借助 ChatGPT Deep Research 工具&#xff0c;对过去十年 WWDC 主题演讲内容进行了系统化分析&#xff0c;形成了这份…...

React Native在HarmonyOS 5.0阅读类应用开发中的实践

一、技术选型背景 随着HarmonyOS 5.0对Web兼容层的增强&#xff0c;React Native作为跨平台框架可通过重新编译ArkTS组件实现85%以上的代码复用率。阅读类应用具有UI复杂度低、数据流清晰的特点。 二、核心实现方案 1. 环境配置 &#xff08;1&#xff09;使用React Native…...

Spring Boot+Neo4j知识图谱实战:3步搭建智能关系网络!

一、引言 在数据驱动的背景下&#xff0c;知识图谱凭借其高效的信息组织能力&#xff0c;正逐步成为各行业应用的关键技术。本文聚焦 Spring Boot与Neo4j图数据库的技术结合&#xff0c;探讨知识图谱开发的实现细节&#xff0c;帮助读者掌握该技术栈在实际项目中的落地方法。 …...

JDK 17 新特性

#JDK 17 新特性 /**************** 文本块 *****************/ python/scala中早就支持&#xff0c;不稀奇 String json “”" { “name”: “Java”, “version”: 17 } “”"; /**************** Switch 语句 -> 表达式 *****************/ 挺好的&#xff…...

docker 部署发现spring.profiles.active 问题

报错&#xff1a; org.springframework.boot.context.config.InvalidConfigDataPropertyException: Property spring.profiles.active imported from location class path resource [application-test.yml] is invalid in a profile specific resource [origin: class path re…...

#Uniapp篇:chrome调试unapp适配

chrome调试设备----使用Android模拟机开发调试移动端页面 Chrome://inspect/#devices MuMu模拟器Edge浏览器&#xff1a;Android原生APP嵌入的H5页面元素定位 chrome://inspect/#devices uniapp单位适配 根路径下 postcss.config.js 需要装这些插件 “postcss”: “^8.5.…...

七、数据库的完整性

七、数据库的完整性 主要内容 7.1 数据库的完整性概述 7.2 实体完整性 7.3 参照完整性 7.4 用户定义的完整性 7.5 触发器 7.6 SQL Server中数据库完整性的实现 7.7 小结 7.1 数据库的完整性概述 数据库完整性的含义 正确性 指数据的合法性 有效性 指数据是否属于所定…...

现有的 Redis 分布式锁库(如 Redisson)提供了哪些便利?

现有的 Redis 分布式锁库&#xff08;如 Redisson&#xff09;相比于开发者自己基于 Redis 命令&#xff08;如 SETNX, EXPIRE, DEL&#xff09;手动实现分布式锁&#xff0c;提供了巨大的便利性和健壮性。主要体现在以下几个方面&#xff1a; 原子性保证 (Atomicity)&#xff…...

在Mathematica中实现Newton-Raphson迭代的收敛时间算法(一般三次多项式)

考察一般的三次多项式&#xff0c;以r为参数&#xff1a; p[z_, r_] : z^3 (r - 1) z - r; roots[r_] : z /. Solve[p[z, r] 0, z]&#xff1b; 此多项式的根为&#xff1a; 尽管看起来这个多项式是特殊的&#xff0c;其实一般的三次多项式都是可以通过线性变换化为这个形式…...