1.Spring5基础知识

最新推荐文章于 2024-07-18 16:02:28 发布
最新推荐文章于 2024-07-18 16:02:28 发布
阅读量150 收藏
点赞数
分类专栏： Spring5 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43864861/article/details/118182689
版权

本篇文章是根据B站狂神说Java系列的Spring5的笔记记录 —— 第一篇Spring5入门了解
gitee：https://gitee.com/ywq869819435/spring5

1、Spring

1.1、简介

  • 2002首次推出了Spirng的雏形：interface21
  • 2004.3月发布spring 1.0
  • 理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的技术框架！
  • SSH： Struct2 + Spring + Hibernate
  • SSM：SpringMvc + Spring + Mybatis

1.2、优点

  • spring是一个开源的免费的框架(容器)！
  • Spring是一个轻量级、非入侵式（不会破坏原项目的运行）的框架！
  • 两个特点：控制反转(IOC)和面向切面编程(AOP)
  • 支持事物的处理，对框架整合的支持

总结

spring就是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架

1.3、组成

在这里插入图片描述

Spring-Core(核心容器)：

Core包是框架的最基础部分，并提供依赖注入（Dependency Injection）管理Bean容器功能。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。

Spring-Context：(Spring核心容器<上下文模块>)

核心模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。这个模块扩展了BeanFactory的概念，增加了消息、事件传播以及验证的支持。另外，这个模块提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括了对模版框架例如Velocity和FreeMarker集成的支持。

Spring-Aop：

Spring在它的AOP模块中提供了对面向切面编程的丰富支持。例如方法拦截器（servletListener ,controller…）和切点，可以有效的防止代码上功能的耦合，这个模块是在Spring应用中实现切面编程的基础。Spring的AOP模块也将元数据编程引入了Spring。使用Spring的元数据支持，你可以为你的源代码增加注释，指示Spring在何处以及如何应用切面函数。

Spring-Dao:

使用JDBC经常导致大量的重复代码，取得连接、创建语句、处理结果集，然后关闭连接、旧代码中迁移自定义工具类JDBCUtil 也让开发变得繁琐。Spring的Dao模块对传统的JDBC进行了抽象，还提供了一种比编程性更好的声明性事务管理方法。

Spring-Web:

Web上下文模块建立于应用上下文模块之上，提供了WEB开发的基础集成特性，例如文件上传。另外，这个模块还提供了一些面向服务支持。利用Servlet listeners进行IOC容器初始化和针对Web的applicationcontext。

Spring Web MVC:

(Model-View-Controller)Spring为构建Web应用提供了一个功能全面的MVC框架。它提供了一种清晰的分离模型，在领域模型代码和web form之间。并且，还可以借助Spring框架的其他特性。

Spring-ORM:

关系映射模块，ORM包为流行的“关系/对象”映射APIs提供了集成层，包括JDO，Hibernate和iBatis（MyBatis）。通过ORM包，可以混合使用所有Spring提供的特性进行“对象/关系”映射，方便开发时小组内整合代码。

1.4、扩展

  • Spring Boot
    • 一个快速的开发的脚手架
    • 基于Spring Boot可以快速的开发单个微服务
    • 约定大于配置！
  • Spring Cloud
    • Spring Cloud 是基于Spring Boot 实现的
  • 写在大部分的公司都在使用SpringBoot进行快速发开，学习SpringBoot的前提，需要完全掌握Spring以及SpringMVC！承上启下的作用
  • 弊端：Spring发展太久之后，违背了原来的理念！配置十分繁琐，人称“配置地狱”

2、IoC理论推导

思想原型

private UserDao userDao;

// 利用set进行动态值的注入
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
  • 在开发系统的时候，往往会存在将对象的创建类型选择或者其他方面的控制权交有程序本身去单一的实现，这样往往存在需求变化的时候需要更改大量源码的问题，成本很高，耦合性高。

在这里插入图片描述

  • 之后设计理念中强调，控制反转，将控制权交由客户，客户就可以更快捷的根据自己的需求去选择对应的对象。系统的耦合性就大大降低了，可以更加专注于业务的实现，程序上就不需要大幅度的更改。

在这里插入图片描述

IOC本质

  • 控制反转IOC（Inversion of Control），是一种设计思想，DI（依赖注入）是显示IOC的一种方法，没有IOC的程序中，使用面向对象编程没对象的创建于对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓的控制反转就是：获得依赖对象的方式反转了

  • 图示：ABCD这个对象原来是直接相互关联的，这时候其实中间可以加多一个IOC容器去控制选择的对象

在这里插入图片描述

  • 采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

  • 控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3、HelloSpring(例子)

3.1、新建一个模块

在这里插入图片描述

3.2、代码内容

code

  • 实体类

    package com.yang.entity;

public class Hello {

    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("Hello"+ name );
    }
}

  • 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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--bean就是java对象 , 由Spring创建和管理
    bean = 对象，这里相当于new Hello();'
    id = 变量名
    class = new 的对象
    property 相当于给对象中的属性设置一个值！
    -->
    <bean id="hello" class="com.yang.entity.Hello">
        <property name="name" value="Spring"/>
    </bean>

</beans>

  • 测试

    import com.yang.entity.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        // 获取spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 所有的对象写在都在Spring中的管理了，要使用直接去里面取出来就可以了
        // getBean: 参数即为spring配置文件中bean的id
        Hello hello = (Hello) context.getBean("hello");
        hello.show();
    }
}

分析

  • Hello对象是由Spring创建的
  • hello对象的属性是由Spring容器设置的
  • 这个由Spring容器创建的过程就是控制反转
  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象
  • 依赖注入 : 本质就是利用set方法来进行注入的（对象中必须有set方法）
  • IOC是一种编程思想 , 由主动的编程变成被动的接收
  • 实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配

简单示例

Spring容器：

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

    <bean id="impl" class="com.yang.dao.UserDaoImpl"/>
    <bean id="mysqlImpl" class="com.yang.dao.UserDaoMysqlImpl"/>
    <bean id="oracleImpl" class="com.yang.dao.UserDaoOracleImpl"/>

    <bean id="userServiceImpl" class="com.yang.service.UserServiceImpl">
        <!-- 相当于setUserDao里面 -->
        <!-- ref: 引用Spring容器中创建好的对象-->
        <!-- value：具体的值，基本数据类型-->
        <property name="userDao" ref="mysqlImpl" />
    </bean>

</beans>

测试启动类：

class testUser {

    @Test
    void getUser() {
        // 写好spring容器配置之后这一段代码不需要再使用
//        UserSerivce userSerivce = new UserServiceImpl();
//        userSerivce.getUser();
        // 写好spring容器配置之后使用如下代码，获取ApplicationContext：
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 有容器之后需要什么就get什么
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
        userServiceImpl.getUser();
    }
}

具体其他类就不再展示。

4、IoC创建对象的方式

  • 默认使用无参构造创建对象

  • 需要使用有参构造写法如下：

    	<!-- 有参构造 -->
    <bean id="user" class="com.yang.entity.User">
        <!-- 第一种方式: 参数下标方式 -->
<!--        <constructor-arg index="0" value="ywq"/>-->
        <!-- 第二种方式: 不建议使用，用类型判断会存在无法识别的问题 -->
<!--        <constructor-arg type="java.lang.String" value="ywq"/>-->
        <!-- 第三种方式: 直接通过参数名称或者引用类型 -->
        <constructor-arg name="name" value="ywq"/>
    </bean>

  • 在配置文件加载的时候，容器中管理的对象就已经初始化了

    public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = (User) context.getBean("user");
    User user2 = (User) context.getBean("user");
    // 这里输出true表明地址相同，只实例化了一个User对象
    System.out.println(user == user2);
    user.show();
}

    在这里插入图片描述

5、Spring配置说明

5.1、Alias别名

<!-- 取别名 -->
<alias name="user" alias="userAlias"/>

在getBean的时候除了用user可以获取对象，还就可以用别名userAlias

5.2、Bean的配置

<!-- 
id： bean的唯一标识符，也就是相当于我们学的对象名
class: bean对象所对应的权限定名(包名 + 类型)
name: 也是取别名，而且name可以同时取多个别名(可以用逗号空格等等分隔符分隔)
scope: 默认单例(以后详细介绍)
autowire: 自动注入方式(以后详细介绍)
-->
<bean id="userT" class="com.yang.entity.UserT" name="user2,u2" scope="" autowire="">
    <proerty name="name" value="ywq"/>
</bean>

5.3、Import

一般用于团队开发使用（一般命名：applicationContext.xml），导入其他的配置文件，合并这些配置文件，使用的时候只需要使用总配置就好

<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

6、DI依赖注入

6.1、构造器注入

之前使用的就是构造器注入

<bean id="userT" class="com.yang.entity.UserT">

</bean>

6.2、Set方式注入【重点】

  • 依赖注入：本质是set注入
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的所有属性，由容器来注入

6.3、扩展方式注入

  • p命名空间：对应简化依赖注入的标签(property)

    <bean id="user" class="com.yang.entity.User"
      p:name="ywq" p:age="21" />

  • c命名空间：对应简化构造器注入的标签(constructor-arg),需要有有参构造器的时候才能使用

    <bean id="user2" class="com.yang.entity.User" 
      c:name="ywq" c:age="21"/>

  • 注意：p和c命名空间需要导入xml约束

    xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6.4、示例

实体类

public class Student {
    private String name;

    private Address address;

    private String[] books;

    private List<String> hobbies;

    private Map<String,String> card;

    private Set<String> games;

    private Properties info;

    private String wife;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", games=" + games +
                ", info=" + info +
                ", wife='" + wife + '\'' +
                '}';
    }
}

public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

注入的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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="address" class="com.yang.entity.Address">
        <property name="address" value="天河区"/>
    </bean>

    <bean id="student" class="com.yang.entity.Student">
        <!-- 普通值的注入value -->
        <property name="name" value="ywq"/>
        <!-- Bean注入ref -->
        <property name="address" ref="address"/>
        <!-- 数组值的注入array -->
        <property name="books">
            <array>
                <value>《红楼梦》</value>
                <value>《西游记》</value>
                <value>《三国演义》</value>
                <value>《水浒传》</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbies">
            <list>
                <value>听歌</value>
                <value>写bug</value>
                <value>看电影</value>
            </list>
        </property>
        <!-- map -->
        <property name="card">
            <map>
                <entry key="身份证" value="123456789012345678"/>
                <entry key="校园卡" value="23156523"/>
            </map>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>CF</value>
                <value>LOL</value>
            </set>
        </property>
        <!-- null值注入-->
        <property name="wife">
            <null/>
        </property>
        <!-- Properties -->
        <property name="info">
            <props>
                <prop key="学号">20210112</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
    </bean>
</beans>

测试启动类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
        System.out.println(student.toString());
    }
}

6.5、Bean的作用域

1.The singleton Scope(单例模式)

单例模式，默认采用这种模式，就是该实体类全局指只实例化一次，也就是在配置类加载的时候就已经实例化，之后的引用都是这个先加载好的对象的地址

<bean id="user2" class="com.yang.entity.User"
      c:name="ywq" c:age="21" scope="singleton"/>

在这里插入图片描述

2.prototype(原型模式)

每一个从容器中get的时候都会产生一个新对象，也就是每一次都是重新申请一块空间进行存储

<bean id="user2" class="com.yang.entity.User"
      c:name="ywq" c:age="21" scope="prototype"/>

在这里插入图片描述

3.request、session、application

这些只能在web开发中使用

  • request：请求创建，在请求完之后这个对象就消失了
  • session：创建完之后一直存在session里面
  • application：全局都存在

7、Bean的自动装配

  • 自动装配：Spring满足Bean依赖的一种方式，就是Spring在上下文中自动寻找，并自动给Bean装配属性
  • 在Spring中有三种装配的方式
    • 在xml中显示的配置
    • 在Java中显示的配置
    • 隐式的自动装配

7.1 、测试环境

测试启动

@Test
public void test1(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Person person = context.getBean("person", Person.class);
    person.getDog().shout();
    person.getCat().shout();
}

配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="cat" class="com.yang.entity.Cat"/>
    <bean id="dog" class="com.yang.entity.Dog"/>

    <bean id="person" class="com.yang.entity.Person">
        <property name="name" value="ywq"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>
</beans>

实体类

public class Person {

    private Cat cat;

    private Dog dog;

    private String name;

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Cat {

    public void shout(){
        System.out.println("喵喵");
    }
}

public class Dog {

    public void shout(){
        System.out.println("汪汪");
    }
}

7.2、ByName自动装配

<bean id="cat" class="com.yang.entity.Cat"/>
<bean id="dog2" class="com.yang.entity.Dog"/>
<!--
byName: 会自动在容器上下文中查找，和自己对象setXXX方法名称后面XXX值对应的bean的id
-->
<bean id="person" class="com.yang.entity.Person" autowire="byName">
    <property name="name" value="ywq"/>
</bean>

在id=“dog”的时候，这里自动装配之后是

在这里插入图片描述

id=“dog2”改变之后是

在这里插入图片描述

7.3、ByType自动装配

  • 需要保证类型全局唯一，id不相同没关系，甚至id都没有配置，因为是根据class的值来匹配
  • 会自动在容器上下文中查找，和自己对象属性值类型后面的值对应的bean的id,需要保证类型全局唯一

在这里插入图片描述

小结

  • byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性和set方法的值一致
  • byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

7.4、使用注解实现自动装配

配置

  • jdk1.5支持的注解，Spring2.5就支持注解了。
  • 具体使用注解还是xml注入，需要根据具体情况决定，一般使用注解会方便很多

注解使用的注意点：

  1. 导入约束：

    <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 
       https://www.springframework.org/schema/context/spring-context.xsd">

  2. 配置注解的支持

    <context:annotation-config/>

相关注解

@Autowired

  • 可以在属性上直接使用，也可以在set方法上使用

  • 使用这个注解，如果自动装配的属性在IoC(Spring)容器中，可以不写set方法

  • 可以配置属性required

    • 默认为true，表示为
    • false，表示这个对象或者属性可以为null，效果可以跟字段加上@Nullable一致

  • 在自动装配的过程中

    • 首先采用ByType的模式匹配，如果结果刚好唯一就给该bean装配
    • 若查询结果不唯一，采用ByName的模式匹配
    • 若查询结果为空，则抛出异常。解决方法时，使得required=false

  • 当使用过程出现，配置了多个相同的类型(先匹配类型，发现用重复的class)，而名称(没有查到id与属性名称相等的属性)无匹配到的时候，可以采用**@Qualifier**(value=“可以匹配的名称”)来解决自动装配匹配不到的问题

    <bean id="cat11" class="com.yang.entity.Cat"/>
<bean id="cat22" class="com.yang.entity.Cat"/>

    在这里插入图片描述

    在这里插入图片描述

@Resource

  • 可以在属性或者方法上使用

  • 自动装配的过程跟@Autowired不相同，默认情况下

    • 首先按照byName模式【按id匹配】进行查找
    • 若byName模式无法查找到，则采用byType模式【按class匹配】去查找

  • 设置属性（只有name和type两种属性）

    • 只设置name：按照设置name值去查找配置里面对应的id值，找不到则抛出异常

    • 只设置type：按照设置type值去查找配置里面对应的class值，查到多个或者没有都会抛异常

    • 设置name和type两者：从Spring上下文中找到唯一匹配的bean(name，type都一致)进行装配，找不到则抛出异常

      在这里插入图片描述

      在这里插入图片描述

  • 功能齐全点，效率会比@Autowired差一点点，但是按照现在硬件条件可以忽略

Resource与Autowired区别
  • 都是自动装配，可以写在变量或者方法上面
  • 前者默认首先byName，后者默认首先byType，且要求这个号对象必须存在
  • 前者可以直接指定name和type，后者需要配置其他注解
@Nullable

表示这个对象或者属性可以为null

@Qualifier

指定这个属性或者方法名称的别名

8、使用注解开发

在Spring4之前，不推荐注解开发，之后推荐

就绪

依赖

在Spring4之后，要使用注解开发，必须要保证AOP的包导入

在这里插入图片描述

xml

使用注解需要导入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
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 指定要扫描的包路径,这个包下的注解就会生效 -->
    <context:component-scan base-package="com.yang.**"/>
    <context:annotation-config/>
    
</beans>

8.1、注入Bean和属性

@Component

表明这个类是一个bean组件，放在类上（说明这个类被Spring管理了）

@Value

表明属性的注入，可以放在set上也可以放在属性上（相当于）

/*表明是组件,等价于<bean id="user" class="com.yang.entity.User"/>*/

@Component
public class User {

    private String name;

    public String getName() {
        return name;
    }

    /*相当于<property name="name" value="ywq"/>*/
    @Value("ywq")
    public void setName(String name) {
        this.name = name;
    }
}

8.2、衍生注解

@Component 有几个衍生注解，也就是细化的注解，本身的功能【注入bean(对象)】都差不多，主要是增加了代码的可读性（当这类bean不好区分的时候采用Component），在web开发中，会按照mvc三层架构分层

  • dao ：习惯使用@Repository进行标注
  • service：习惯使用@Service进行标注
  • controller：习惯使用@Controller进行标注

四个注解的功能都是一样的，都是代表将某个类注册到Spring容器中，装配Bean

8.3、自动装配的注解

  • @Autowired：自动装配先通过类型，然后名字
    • @Qualifier(value=“xxx”): 如果Autowired不能唯一自动装配上属性，则需要通过这个注解起别名
  • @Resource：自动装配先通过名称，然后类型
  • @Nullable：字段标记了这个注解,说明这个字段可以为null
  • @Scope(“xxx”)：采用什么模式进行实例化【singleton单例模式、prototype原型模式】

小结

xml与注解：

  • xml更加万能，适用于任何场合！维护简单方便
  • 注解 不是自己的类使用不了，维护相对复杂

xml与注解最佳实践：

  • xml用来管理bean（只注入类【bean】）

  • 注解只负责完成属性的注入（注入属性值）

  • 使用的过程中，只需要注意一个问题：必须让注解生效，就是需要开启注解的支持

    <!-- 指定要扫描的包路径,这个包下的注解就会生效 -->
<context:component-scan base-package="com.yang.**"/>
<context:annotation-config/>

9、使用Java的方式配置Spring

  • 已经支持java的代码去替代Spring的xml配置了（完全由Java处理，Spring5页推荐这样去完成，更加灵活）

在这里插入图片描述

在这里插入图片描述

创建配置类

@Configuration

  • 其源码就包含@Component注解，也就是本身就是一个组件，会被Spring托管
  • @Configuration代表这是一个配置类，就和之前看的xml内的

示例

@Configuration
public class MyConfig {
    
}

两种注入Bean的方式

@Bean

使用@Bean注解
  • 注册一个在方法上写Bean,就相当于
  • 方法名等于bean标签中的id属性
  • 返回值等于bean标签中的class属性
示例

配置类

@Configuration
public class MyConfig {

    // 注册一个bean,就相当于<bean></bean>
    // 方法名等于bean标签中的id属性
    // 返回值等于bean标签中的class属性

    @Bean
    public User getUser(){
        // 返回要注入bean的对象
        return new User();
    }
}

要注入的类

public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("ywq")
    public void setName(String name) {
        this.name = name;
    }

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

测试启动类

public class MyTest {

    @Test
    void test1(){
        // 如果完全使用了配置类方法去做，只能通过AnnotationConfig上下文获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User user = context.getBean("getUser", User.class);
        System.out.println(user.getName());
    }
}

@ComponentScan+@Component

@ComponentScan
  • 配置扫描包，包下的类自动装配组件(有@Component注解的类)
  • 其中bean标签中的属性id值为类名,class为类的类型
示例

配置类

@Configuration
@ComponentScan("com.yang.entity")
public class MyConfig {
}

要注入的类

@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("ywq")
    public void setName(String name) {
        this.name = name;
    }

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

测试启动类

public class MyTest {

    @Test
    void test1(){
        // 如果完全使用了配置类方法去做，只能通过AnnotationConfig上下文获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User user = context.getBean("user", User.class);
        System.out.println(user.getName());
    }
}

导入其他配置类

@Import(value = [需要导入的配置类的类型])

示例

主配置类

@Configuration
@ComponentScan("com.yang.entity")
@Import(value = ImportConfig.class)
public class MyConfig {
}

要导入的配置类

@Configuration
public class ImportConfig {
}
笨鸟不会先飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring5学习之基础知识总结
p1830095583的博客
05-30 435
1.概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、 Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop IOC：控制反转，把创建对象过程交给 Spring 进行管理Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 方便解耦，简化开发Aop 编程支持方便程序测试方便和其他框架进行整合方便进行事务操作降低 API 开发难度 2.入门Demo 1.jar包引入 <project xmlns="http://maven
spring依赖注入基础知识.rar
01-14
下面我们将深入探讨Spring依赖注入的基础知识。 一、依赖注入的概念 依赖注入是一种设计模式，它将一个对象所需要的服务（依赖）通过构造函数、setter方法或者配置文件等方式传入，而不是由对象自己创建或查找依赖...
Spring5知识点简要梳理
字节幺零二四的博客
03-24 137
对Spring5的知识点作简要梳理，基于xml配置文件和注解两种方式，实现IOC和AOP，同时通过Spring配置JDBCTemplate实现对数据库的增删改查和事务管理
Spring5基本知识
qq_33813721的博客
12-01 486
本篇论述的内容 spring历史； spring Ioc; spring自动装配； spring aop； spring 事务 注：本文内容来自b站狂神说java spring框架学习的笔记 一、spring简介 二、spring Ioc 三、spring自动装配 三、spring aop 3.1、静态/动态代理 ...
Spring5-基础知识
发型决定高度的博客
11-11 469
Spring 1. Spring的基本概述 spring是一个轻量级的JAVAEE的开源框架 spring可以解决企业级应用开发的复杂性 spring有两个核心部分IOC和AOP： IOC：控制反转，把创建对象的过程交给spring进行管理 AOP：面向切面，在不修改源代码的情况下进行功能的增强 spring的特点： 方便解藕，简化开发 Aop编程的支持 方便测试的集成 方便和其他的框架进行整合 方便进行事务的操作和降低api的使用难度
Spring5知识点总结（二、AOP）
weixin_43369516的博客
11-15 444
1.代理模式 动态代理和静态代理 角色一样 动态代理类是动态生成的，不是我们直接写好的！ 动态代理：基于接口，基于类 基于接口：JDK的动态代理【使用】 基于类：cglib java字节码 静态代理 动态代理 //这个类，自动生成代理类 public class ProxyInvocation implements InvocationHandler { //被代理的接口 private Rent rent; public void setRent(Rent re
Spring的基础知识.pptx
12-26
【Spring基础知识】 Spring是一个广泛使用的Java企业级应用程序框架，主要设计目的是降低模块间的耦合度，提供一种轻量级的开发方式。Spring的核心特性包括依赖注入（IoC）和面向切面编程（AOP）。它不仅关注业务层...
Spring5笔记与代码.zip
09-25
《Spring5笔记与代码》是针对Spring框架第五个主要版本的学习资源，包含了理论知识和实践代码，旨在帮助用户深入理解并掌握Spring5的核心概念和技术。本文将详细解析这些知识点，并结合提供的文件进行深入探讨。 ...
com.atguigu.springcloud
03-31
Spring框架本身就是Java平台上的一个核心库，而SpringBoot和SpringCloud都是在此基础上构建的，旨在简化Java开发和部署过程。 【压缩包子文件的文件名称列表】"com.atguigu.springcloud-master"通常表示这是一个Git...
Spring基础知识详解
10-19
下面将对Spring的基础知识进行详细的解释。 1. **依赖注入（Dependency Injection，DI）**：Spring的核心特性，它允许开发者通过外部配置来管理对象及其依赖关系，而不是在代码中硬编码这些依赖。这样可以提高代码...
spring5框架知识点总结（一）IOC篇
m0_50654102的博客
03-27 294
spring5框架知识点总结 Spring5 框架概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 I
Spring5「知识点整理」中......
10-04 198
Spring5-知识点整理欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使...
Spring5知识点总结——事务
weixin_43369516的博客
11-15 379
1.声明式事务 事务的acid原则： 原子性 一致性 隔离性 多个业务可能操作一个资源，防止数据损坏 持久性 事务一旦提交，无论系统发生什么问题，结果都不会被影响。 Spring中的事务管理 声明式事务：AOP 编程式事务：代码管理事务 spring事务的七种事务属性： PROPAGATION_REQUIRED – 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS – 支持当前事务，如果当前没有事务，就以非事务方式执行 PROPAGATI
2021年最详细的Spring5知识点
远赴人间惊鸿宴,一睹人间盛世颜！
05-25 270
IOC(接口) 1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。 2.Spring提供IOC容器实现的两种方式：（两个接口） （1）BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用。 特点：加载配置文件的时候不会创建对象，在获取对象（使用）才去创建对象。 （2）ApplicationContext:BeanFactory接口的子接口，提供更多更强大的功能，一般是由开发人员进行使用。 特点：加载配置文件时就会把配置文件对象进行创建。
Spring实战（第5版）核心知识点总结
weixin_42101628的博客
03-14 1860
Spring实战（第5版）1. Spring基础1.1 Spring起步1.2 开发Web应用1.3 使用数据1.4 保护Spring1.5 使用配置属性2. Spring集成3. 反应式Spring4. 云原生Spring5. 部署Spring 1. Spring基础 1.1 Spring起步 Spring的核心是提供一个容器（container），又叫spring Application Context，会创建和管理bean，将bean装配在一起基于依赖注入（DI），依赖容器去创建和维护所有的组件，注入
java框架：超详细Spring知识点汇总
热门推荐
pingdouble的专栏
03-12 1万+
1spring框架概述1.1什么是springlSpring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用...
2 IOC容器初始化过程
惟愿无事
07-25 8750
IOC容器的初始化分为三个过程实现： 第一个过程是Resource资源定位。这个Resouce指的是BeanDefinition的资源定位。这个过程就是容器找数据的过程，就像水桶装水需要先找到水一样。 第二个过程是BeanDefinition的载入过程。这个载入过程是把用户定义好的Bean表示成Ioc容器内部的数据结构，而这个容器内部的数据结构就是BeanDefition。 第三
Spring纯注解开发
最新发布
Admans的专栏
07-18 846
Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦注解开发前，配置Bean时是在xml里将class分别写在Bean标签里，然后起id，就像这样注解开发后，配置Bean时首先将xml里的标签删掉，然后在类上添加@Component注解即可在xml文件中来写一个扫描包的注解标签，对象就装进IOC容器里了component-scan:component意为组件，scan意为扫描。
SpringBoot集成EasyExcel实现模板写入多个sheet导出
LynneZoe的博客
07-18 454
SpringBoot集成EasyExcel实现模板写入多个sheet导出。
spring boot 基础知识
11-10
以下是一些Spring Boot的基础知识： 1. Spring Boot的优点是什么？ Spring Boot可以帮助开发者快速搭建Spring应用程序，提供了很多开箱即用的功能，例如自动配置、内嵌服务器、安全性等等。这些功能可以让开发者...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值