第四章：Spring上

最新推荐文章于 2024-11-10 21:05:45 发布
最新推荐文章于 2024-11-10 21:05:45 发布
阅读量413 收藏
点赞数
分类专栏： SSM 文章标签： spring python java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wcy_0522/article/details/131989921
版权

第四章：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中可以使用XML和Java注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。

      6. 声明式

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

      7. 一站式

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

    • Spring Framework五大功能模块

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

4.2：IOC

  1. IOC容器

    • IOC思想

      IOC：Inversion of Control，翻译过来是反转控制。

      1. 获取资源的传统方式

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

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

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

      3. DI

        ​ DI：Dependency Injection，翻译过来是依赖注入。

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

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

    • IOC容器在spring中的实现

      ​ Spring的IOC容器就是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容器中的bean
    HelloWorld helloworld = (HelloWorld)ioc.getBean("helloworld");
    helloworld.sayHello();
}

在这里插入图片描述

  • 实验二：获取bean

    创建一个新的模块，spring_ioc_xml_08，并引入spring_helloworld_07模块pom.xml的jar包。创建一个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这个bean在IOC容器中有多个实例获取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对象设置属性。
      • 后置处理器的postProcessBeforeInitialization：bean对象初始化之前操作(由bean的后置处理器负责)。
      • 初始化，需要通过bean的init-method：对象的初始化(需要配置bean时指定初始化方法)。
      • 后置处理器的postProcessAfterInitialization：bean对象初始化之后操作(由bean的后置处理器负责)。
      • IOC容器关闭时销毁，需要通过bean的destroy-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的生命周期初始化之前执行
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor--->后置处理器postProcessBeforeInitialization");
        return bean;
    }
    // 此方法在bean的生命周期初始化之后执行
    @Override
    public 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. 简介

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

      package org.springframework.beans.factory;

public interface FactoryBean<T> {
	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

	@Nullable
	T getObject() throws Exception;

	@Nullable
	Class<?> getObjectType();

	default boolean isSingleton() {
		return true;
	}
}

    2. 创建类UserFactoryBean

      package com.wang.factory;

public class UserFactoryBean implements FactoryBean<User> {
    @Override
    public User getObject() throws Exception {
        return new User();
    }

    @Override
    public 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 {

    @Override
    public 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;
    }

    @Override
    public 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. 组件所对应的bean的id

        ​ 通过注解+扫描所配置的bean的id，默认值为类的小驼峰，即类名的首字母为小写的结果。可以通过标识组件的注解的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的方式实现自动装配的效果。
        • 若byType和byName的方式都无法实现自动装配，即IOC容器中有多个类型匹配的bean且这些bean的id要赋值的属性的属性名都不一致，此时抛异常：NoUniqueBeanDefinitionException。
        • 此时可以在要赋值的属性上，添加一个注解@Qualifier，通过该注解的value属性值，指定某个bean的id，将这个bean为属性赋值。

      4. Autowired注解的注意事项

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

小王超会敲代码
关注
专栏目录
第四章：Spring AOP API 设计模式1
08-03
4. **原型模式（Prototype）**：Spring AOP中的`PrototypeTargetSource`实现了原型模式，它允许创建对象的克隆，用于动态地替换目标对象，提供了一种高效创建对象的方式，特别是在需要大量创建相似对象时。...
第二章：Spring AOP 基础1
08-03
在本章"Spring AOP 基础1"中，我们主要探讨了Spring AOP（面向切面编程）的核心概念和实现方式。AOP是一种编程范式，它允许程序员定义"切面"，这些切面封装了跨越多个对象的横切关注点，如日志、事务管理等。以下是...
第三章：Spring AOP API 设计与实现1
08-03
本章主要涵盖了Spring AOP的多个核心概念和实现机制。 1. **整体设计**：Spring AOP API的设计目标是为应用程序提供灵活的切面编程能力。它通过AOP代理来拦截方法调用，执行相应的Advice，实现了切面的透明插入。 ...
Spring第七章：Spring+Mybatis快速开发素材(静态页+配置文件模板).rar
06-07
在本资源包中，我们关注的是Spring框架与Mybatis的集成应用，这是一套常见的Java Web开发技术组合，尤其适用于快速构建数据驱动的Web应用程序。Spring作为一款强大的企业级应用框架，提供了依赖注入、AOP（面向切面...
第四章 Spring Bean基础1
08-03
4. **Spring Bean 的别名**： - **别名的作用**：为同一个 Bean 提供多个访问名称，方便不同场景下的引用。 - **创建别名**：在 XML 配置中使用 `name` 属性，并用逗号或分号分隔多个别名。 5. **注册 Spring ...
spring-security（记住密码，CSRF）
最新发布
2302_79087378的博客
11-10 478
PersistentTokenRepository实现类InMemoryTokenRepositoryImpl基于内存实现JdbcTokenRepositoryImpl基于数据库实现@Bean。
后端SpringBoot及vue proxyTable解决跨域
qq_42059717的博客
11-06 395
昨天上线项目遇到了一个奇怪的问题，本来服务实在腾讯云的轻量应用服务器的，但是迁移到一个香港的服务器之后就出现了各种各样的问题。Nginx 开启Https Springboot开启Https，先后出现了噔噔蹬蹬但是我其实已经部署了一个项目了的，那个用的proxyTable,新部署的这个用的是里边的env控制的。后来改成proxyTable就好了。
Spring中@Autowired@Resource和@Inject注解区别
2401_87333857的博客
11-06 439
同时，它默认是采用byType装配，当指定了1SR-330规范中的@Named注解之后，变成byName装配。它也可以出现在方法上，构造函数上和字段上但是需要注意的是:因为IRE无法决定构造方法注入的优先级，所以规范中规定类中只能有一个构造方法带@Inject注解。@Autowired:来源于spring框架自身默认是byType自动装配，当配合了@Qualifier注解之后，在没有指定name属性时是byType自动装配，当指定了name属性之后，采用byName方式自动装配。
SpringBoot助力的共享汽车业务优化系统
2402_85762143的博客
11-09 1056
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 659
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
为何选择Spring AI Alibaba开发智能客服平台？
JavaEdge全是干货的技术号
11-09 788
本文来看如何使用Spring AI Alibaba构建Agent应用。
七、Spring Boot集成Spring Security之前后分离认证最佳实现
JavaEE技术进阶之路
11-06 987
前后分离项目认证流程代码实现，基于spring security原生流程设计，实现RESTFUL接口、分布式缓存
Spring-Day8
2301_78630849的博客
11-09 531
一组关联的数据库操作；要么都成功，要么都失败，保证业务操作完整性的一种数据库机制。
springboot使用aop防御用户重复请求
干货分享，希望帮助读者不断提升自己的编程技能，解决工作中实际问题，并激发对技术的无限热爱。
11-09 604
使用springboot，aop技术防御用户重复请求，减少无效请求，可以更有效地分配资源，提高资源利用率。
spring-security
2302_79087378的博客
11-08 710
*** 登录服务类，实现Spring Security的UserDetailsService接口*/@Service/*** 根据用户名加载用户信息* @param username 用户名* @return UserDetails对象，包含用户信息* @throws UsernameNotFoundException 如果用户不存在，则抛出此异常*/@Override// 检查用户名是否匹配预设值，如果不匹配则抛出异常if (!
springBoot 自动配置与starter
水w的博客
11-07 778
springBoot 自动配置与starter
配置文件中spring.cloud.consul.host属性
weixin_42594143的博客
11-06 201
spring.cloud.consul.host属性是SpringCloudConsul项目中的一个关键配置项，它用于指定Consul服务器的主机地址。在SpringBoot应用程序中，spring.cloud.consul.host属性通常配置在application.yml或application.properties文件中。• 确保Consul服务可用：在配置spring.cloud.consul.host属性之前，需要确保Consul服务已经启动并运行在指定的主机和端口上。
w025基于SpringBoot网上超市的设计与实现
卓怡工作室的博客
11-07 1071
网络技术和计算机技术发展至今，已经拥有了深厚的理论基础，并在现实中进行了充分运用，尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代，所以对于信息的宣传和管理就很关键。因此超市商品销售信息的管理计算机化，系统化是必要的。设计开发网上超市系统不仅会节约人力和管理成本，还会安全保存庞大的数据量，对于超市商品销售信息的维护和检索也不需要花费很多时间，非常的便利。 网上超市系统是在MySQL中建立数据表保存信息，运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计
【MongoDB】MongoDB的Java API及Spring集成（Spring Data）
A的博客
11-07 1210
通过 Spring Data MongoDB，我们可以轻松地将 MongoDB 数据库的操作与 Spring 应用集成，并且能够以声明式的方式进行数据访问，而无需直接编写大量的 MongoDB 操作代码。以下是一个使用 Spring Data MongoDB 的基本示例，展示了如何将 MongoDB 集成到 Spring Boot 应用中，执行 CRUD 操作。以上一个简单的MongoDB使用就完善了，在业务中更多的也是如此的CRUD，后续文章会写一些关于MongoDB的底层原理，毕竟面试要造火箭。
Spring in Action 第三版：核心技术与应用集成
- **第4章：Aspect-oriented Spring**：介绍Spring AOP（面向切面编程）的概念，演示如何利用它进行代码分离和横切关注点的处理。 **第二部分：Spring应用基础** - **第5章：Hitting the Database**：深入讨论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值