AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

spring（1）

2024-06-06 29
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： spring

1、Spring简介

1.1、Spring概述

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

Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用

Spring 框架来创建性能好、易于测试、可重用的代码。

Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首

次在 Apache 2.0 许可下发布。

Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。

Spring 框架的核心特性是可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应

用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO

编程模型来促进良好的编程实践。

[!note]

还不怎么理解

视频

1.2、Spring家族

项目列表：https://spring.io/projects

1.3、Spring Framework

Spring 基础框架，可以视为 Spring 基础设施，其他spring项目都是以spring Framework为基础的

1.3.1、Spring Framework特性
  • 非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常小。对领域模型可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。
  • 控制反转：IOC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源
    变成环境将资源准备好，我们享受资源注入。

[!note]

把对象的创建权和控制权交给spring

  • 面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。
  • 容器：Spring IOC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。
  • 组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。
  • 声明式：很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。
  • 一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基础上全部使用 Spring 来实现。
1.3.2、Spring Framework五大功能模块
功能模块 功能介绍
Core Container 核心容器，在 Spring 环境下使用任何功能都必须基于 IOC 容器。
AOP&Aspects 面向切面编程
Testing 提供了对 junit 或 TestNG 测试框架的整合。
Data Access/Integration 提供了对数据访问/集成的功能。
Spring MVC 提供了面向Web应用程序的集成功能。

2、IOC

2.1、IOC容器

2.1.1、IOC思想

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

①获取资源的传统方式

自己做饭：买菜、洗菜、择菜、改刀、炒菜，必须熟悉资源创建的所有细节而且掌控他们

在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的

模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。

②反转控制方式获取资源

点外卖：下单、等、吃，省时省力，不必关心资源创建过程的所有细节。把细节给spring做,自己获得最后的结果

③DI

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

DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器

的资源注入。相对于IOC而言，这种表述更直接。

所以结论是：IOC 就是一种反转控制的思想， 而 DI 是对 IOC 的一种具体实现方式。

2.1.2、IOC容器在Spring中的实现

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

①BeanFactory

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

②ApplicationContext

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用

ApplicationContext 而不是底层的 BeanFactory。

③ApplicationContext的主要实现类

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

2.2、基于XML管理bean

2.2.1、实验一：入门案例

①创建Maven Module
②引入依赖
<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>

③创建类HelloWorld
public class HelloWorld {  
    public void sayHello(){  
        System.out.println("helloworld");  
    }  
}

现在可以指定xml获得ioc容器

⑤在Spring的配置文件中配置bean

bean是spring的一个组件换句话来说是spring管理的一个对象

<!--
  配置HelloWorld所对应的bean，即将HelloWorld的对象交给Spring的IOC容器管理
  通过bean标签配置IOC容器所管理的bean
  属性：
    id：设置bean的唯一标识
    class：设置bean所对应类型的全类名
-->
<bean id="helloworld" class="com.atguigu.spring.bean.HelloWorld"></bean>
⑥创建测试类测试

resources和java最终加载到同一个路径下,即类路径下面所以可以直接写文件名

@Test
public void testHelloWorld(){
    ApplicationContext ac = newClassPathXmlApplicationContext("applicationContext.xml");
      HelloWorld helloworld = (HelloWorld) ac.getBean("helloworld");
      helloworld.sayHello();
}
⑦思路

[!note]

知道了bean的id就知道了我们要创建对象的类型,在类型不确定的情况下我们要创建和管理对象要用反射和工厂模式

⑧注意

Spring 底层默认通过反射技术调用组件类的无参构造器来创建组件对象，这一点需要注意。如果在需要无参构造器时，没有无参构造器，则会抛出下面的异常：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name

‘helloworld’ defined in class path resource [applicationContext.xml]: Instantiation of bean

failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed

to instantiate [com.atguigu.spring.bean.HelloWorld]: No default constructor found; nested

exception is java.lang.NoSuchMethodException: com.atguigu.spring.bean.HelloWorld.

()

原因是有参构造可以是多种样子的,并不好自动构造出来对象

2.2.2、实验二：获取bean

①方式一：根据id获取

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

上个实验中我们使用的就是这种方式。

②方式二：根据类型获取

[!danger]

有多个类型匹配的bean会出错

@Test  
 @Test  
    public void testIOC(){  
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");  
        Student studentOne = (Student) ioc.getBean("studentOne");  
//        通过类来获取  
        Student bean = ioc.getBean(Student.class);  
        System.out.println(studentOne);  
  
    }

所以有了以下方式获取

③方式三：根据id和类型
@Test  
public void testHelloWorld(){  
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");  
    HelloWorld bean = ac.getBean("helloworld", HelloWorld.class);  
    bean.sayHello();  
}
④注意

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个

当IOC容器中一共配置了两个：

<bean id="helloworldOne" class="com.atguigu.spring.bean.HelloWorld"></bean>  
<bean id="helloworldTwo" class="com.atguigu.spring.bean.HelloWorld"></bean>

根据类型获取时会抛出异常：

> org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean
> 
> of type 'com.atguigu.spring.bean.HelloWorld' available: expected single matching bean but
> 
> found 2: helloworldOne,helloworldTwo

如果bean没有也会报错

⑤扩展

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

可以，前提是bean唯一

public class Student implements Person

@Test  
    public void testIOC(){  
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");  
        Student studentOne = (Student) ioc.getBean("studentOne");  
//        通过类来获取  
//        Student bean = ioc.getBean(Student.class);  
//        System.out.println(studentOne);  
        Person bean = ioc.getBean(Person.class);  
        System.out.println(bean);  
  
    }

可以根据接口类型获得对象,因为是兼容的

如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？

不行，因为bean不唯一

⑥结论

根据类型来获取bean时，必须要满足bean唯一的情况下，其实只是看：『对象 instanceof 指定的类

型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到

[!note]

就是当前bean本身的类型所继承的类型所实现的接口类型都可以

2.2.3、实验三：依赖注入之setter注入

依赖注入是ioc的一种具体的实现方式,就是设置好方法然后来接收对象

创建学生类Student
package com.atguigu.spring.pojo;  
  
public class Student implements Person{  
    private Integer sid;  
    private String sname;  
    private Integer age;  
    private String gender;  
  
    public Integer getSid() {  
        return sid;  
    }  
  
    public void setSid(Integer sid) {  
        this.sid = sid;  
    }  
  
    public String getSname() {  
        return sname;  
    }  
  
    public void setSname(String sname) {  
        this.sname = sname;  
    }  
  
    public Integer getAge() {  
        return age;  
    }  
  
    public void setAge(Integer age) {  
        this.age = age;  
    }  
  
    public String getGender() {  
        return gender;  
    }  
  
    public void setGender(String gender) {  
        this.gender = gender;  
    }  
  
    @Override  
    public String toString() {  
        return "Student{" +  
                "sid=" + sid +  
                ", sname='" + sname + '\'' +  
                ", age=" + age +  
                ", gender='" + gender + '\'' +  
                '}';  
    }  
}
配置bean时属性赋值
<bean id="studentOne" class="com.atguigu.spring.pojo.Student">  
    <!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 -->  
    <!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关）-->  
    <!-- value属性：指定属性值 -->  
    <property name="sid" value="1001"></property>  
    <property name="sname" value="张三"></property>  
    <property name="age" value="23"></property>  
    <property name="gender" value="男"></property>  
</bean>
测试
@Test  
public void testDI(){  
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");  
    Student studentTwo = ioc.getBean("studentTwo", Student.class);  
    System.out.println(studentTwo);  
  
  
}

2.2.4、实验四：依赖注入之构造器注入

①在Student类中添加有参构造
public Student(Integer sid, String sname, Integer age, String gender) {  
    this.sid = sid;  
    this.sname = sname;  
    this.age = age;  
    this.gender = gender;  
}```
#### ②配置bean
```xml
<bean id="studentThree" class="com.atguigu.spring.pojo.Student">  
    <constructor-arg value="1002"></constructor-arg>  
    <constructor-arg value="李四"></constructor-arg>  
    <constructor-arg value="33"></constructor-arg>  
   <constructor-arg value="女"></constructor-arg>  
</bean>

如果遇到有参构造不好识别是那种的情况需要指定参数名

注意：

constructor-arg标签还有两个属性可以进一步描述构造器参数：

  • index属性：指定参数所在位置的索引（从0开始）
  • name属性：指定参数名

③测试

public void testDI(){  
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");  
    Student studentTwo = ioc.getBean("studentThree", Student.class);  
    System.out.println(studentTwo);  
  
  
}

2.2.5、实验五：特殊值处理

①字面量赋值

什么是字面量？

int a = 10;

这里的就是字面量

声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a

的时候，我们实际上拿到的值是10。

而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面

量。所以字面量没有引申含义，就是我们看到的这个数据本身。

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

注意：

`<property name="name" value="null"></property>`

以上写法，为name所赋的值是字符串null

③xml实体
<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替 -->
<property name="expression" value="a &lt; b"/>
④CDATA节

要写在value的子标签里面,CDATA节是xml中一个特殊的标签，因此不能写在一个属性中

<property name="expression">
    <!-- 解决方案二：使用CDATA节 -->
    <!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->
    <!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->
    <!-- 所以CDATA节中写什么符号都随意 -->
    <value><![CDATA[a < b]]></value>
</property>

2.2.6、实验六：为类类型属性赋值

①创建班级类Clazz
public class Clazz {
    private Integer clazzId;
    private String clazzName;
    public Integer getClazzId() {
        return clazzId;
    }
    public void setClazzId(Integer clazzId) {
        this.clazzId = clazzId;
    }
    public String getClazzName() {
        return clazzName;
    }
    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }
    @Override
    public String toString() {
        return "Clazz{" +
            "clazzId=" + clazzId +
            ", clazzName='" + clazzName + '\'' +
            '}';
    }
    public Clazz() {
    }
    public Clazz(Integer clazzId, String clazzName) {
        this.clazzId = clazzId;
        this.clazzName = clazzName;
    }
}
②修改Student类

在Student类中添加以下代码：

private Clazz clazz;
public Clazz getClazz() {
    return clazz;
}
public void setClazz(Clazz clazz) {
    this.clazz = clazz;
}
③方式一：引用外部已声明的bean

就是用bean给类属性的变量赋值

配置Clazz类型的bean：

<bean id="clazzOne" class="com.atguigu.spring.pojo.Clazz">  
    <property name="clazzId" value="1111"></property>  
    <property name="clazzName" value="一班"></property>  
</bean>

为Student中的clazz属性赋值：

[!note]

ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值

<bean id="studentFour" class="com.atguigu.spring.bean.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->
    <property name="clazz" ref="clazzOne"></property>
</bean>

④方式二：内部bean
<bean id="studentFive" class="com.atguigu.spring.pojo.Student">
    <property name="sid" value="1004"></property>
    <property name="sname" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="gender" value="女"></property>
    <property name="clazz">
        <!-- 在一个bean中再声明一个bean就是内部bean -->
        <!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 -->
        <bean id="clazzInner" class="com.atguigu.spring.bean.Clazz">
            <property name="clazzId" value="2222"></property>
            <property name="clazzName" value="远大前程班"></property>
        </bean>
    </property>
</bean>

内部bean不能直接通过ioc容器获取

③方式三：级联属性赋值
<bean id="studentFour" class="com.atguigu.spring.bean.Student">
    <property name="id" value="1004"></property>
    <property name="name" value="赵六"></property>
    <property name="age" value="26"></property>
    <property name="sex" value="女"></property>
    <!-- 一定先引用某个bean为属性赋值，才可以使用级联方式更新属性 -->
    <property name="clazz" ref="clazzOne"></property>
    <property name="clazz.clazzId" value="3333"></property>
    <property name="clazz.clazzName" value="最强王者班"></property>
</bean>

2.2.7、实验七：为数组类型属性赋值

①修改Student类

在Student类中添加以下代码：

private String[] hobby;
public String[] getHobby() {  
    return hobby;  
}  
  
public void setHobby(String[] hobby) {  
    this.hobby = hobby;  
}
②配置bean
<bean id="studentFive" class="com.atguigu.spring.pojo.Student">  
    <property name="sid" value="1004"></property>  
    <property name="sname" value="赵六"></property>  
    <property name="age" value="26"></property>  
    <property name="gender" value="女"></property>  
    <property name="clazz">  
        <!-- 在一个bean中再声明一个bean就是内部bean -->  
        <!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 -->  
        <bean id="clazzInner" class="com.atguigu.spring.pojo.Clazz">  
            <property name="clazzId" value="2222"></property>  
            <property name="clazzName" value="远大前程班"></property>  
        </bean>  
    </property>  
    <property name="hobby">  
        <array>  
            <value>抽样</value>  
            <value>喝酒</value>  
            <value>烫头</value>  
        </array>  
    </property>  
</bean>

若是类类型

③测试

2.2.8、实验八：为集合类型属性赋值

①为List集合类型属性赋值

在Clazz类中添加以下代码：

private List<Student> students;
public List<Student> getStudents() {
    return students;
}
public void setStudents(List<Student> students) {
    this.students = students;
}

配置bean：

<bean id="clazzOne" class="com.atguigu.spring.pojo.Clazz">  
    <property name="clazzId" value="1111"></property>  
    <property name="clazzName" value="一班"></property>  
    <property name="students">  
        <list>  
            <ref bean="studentTwo"></ref>  
            <ref bean="studentThree"></ref>  
        </list>  
    </property>  
</bean>

测试

使用list类型的bean

[!danger]

原本bean只能给属性赋值并不能填充数据,所以要引入新的依赖

<bean id="clazzOne" class="com.atguigu.spring.pojo.Clazz">  
    <property name="clazzId" value="1111"></property>  
    <property name="clazzName" value="一班"></property>  
    <property name="students" ref="studentList">  
  
    </property>  
</bean>  
<util:list id="studentList">  
    <ref bean="studentThree"></ref>  
    <ref bean="studentTwo"></ref>  
</util:list>

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

②为Map集合类型属性赋值

创建教师类Teacher：

public class Teacher {
    private Integer teacherId;
    private String teacherName;
    public Integer getTeacherId() {
        return teacherId;
    }
    public void setTeacherId(Integer teacherId) {
        this.teacherId = teacherId;
    }
    public String getTeacherName() {
        return teacherName;
    }
    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }
    public Teacher(Integer teacherId, String teacherName) {
        this.teacherId = teacherId;
        this.teacherName = teacherName;
    }
    public Teacher() {
    }
    @Override
    public String toString() {
        return "Teacher{" +
            "teacherId=" + teacherId +
            ", teacherName='" + teacherName + '\'' +
            '}';
    }
}

在Student类中添加以下代码：

private Map<String, Teacher> teacherMap;
public Map<String, Teacher> getTeacherMap() {
    return teacherMap;
}
public void setTeacherMap(Map<String, Teacher> teacherMap) {
    this.teacherMap = teacherMap;
}

配置bean：

<bean id="studentFive" class="com.atguigu.spring.pojo.Student">  
    <property name="sid" value="1004"></property>  
    <property name="sname" value="赵六"></property>  
    <property name="age" value="26"></property>  
    <property name="gender" value="女"></property>  
    <property name="clazz">  
        <!-- 在一个bean中再声明一个bean就是内部bean -->  
        <!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 -->  
        <bean id="clazzInner" class="com.atguigu.spring.pojo.Clazz">  
            <property name="clazzId" value="2222"></property>  
            <property name="clazzName" value="远大前程班"></property>  
        </bean>  
    </property>  
    <property name="hobby">  
        <array>  
            <value>抽样</value>  
            <value>喝酒</value>  
            <value>烫头</value>  
        </array>  
    </property>  
    <property name="teacherMap">  
        <map>  
            <entry key="10086" value-ref="teacherOne"></entry>  
            <entry key="1992" value-ref="teacherTwo"></entry>  
        </map>  
    </property>  
</bean>  
  
<bean id="teacherOne" class="com.atguigu.spring.pojo.Teacher">  
    <property name="teacherId" value="10010"></property>  
    <property name="teacherName" value="大宝"></property>  
</bean>  
<bean id="teacherTwo" class="com.atguigu.spring.pojo.Teacher">  
    <property name="teacherId" value="10086"></property>  
    <property name="teacherName" value="二宝"></property>  
</bean>

引用map集合的bean

<util:map id="teacherMap">  
    <entry key="10086" value-ref="teacherOne"></entry>  
    <entry key="10010" value-ref="teacherTwo"></entry>  
</util:map>

spring（2）https://developer.aliyun.com/article/1530430

文章标签：
Java
容器
Spring
数据格式
XML
凌寒ᨐ舞
目录
相关文章
DJJ懒洋洋
|
Java Spring 容器
Spring(1)
Spring(1)
DJJ懒洋洋
43 0
爱你三千遍斯塔克
|
6月前
|
Java API Maven
spring使用01
spring使用01
爱你三千遍斯塔克
31 0
spring使用01
aliyun7689123603-22772
|
2月前
|
XML Java 数据格式
Spring介绍
【10月更文挑战第9天】
aliyun7689123603-22772
71 1
dlwlrma-晴子
|
2月前
|
Java 应用服务中间件 Maven
Spring
Spring
dlwlrma-晴子
18 0
JavaPub
|
6月前
|
前端开发 Java 数据库连接
一篇告诉你什么是Spring
一篇告诉你什么是Spring
JavaPub
138 0
一百减一是零
|
7月前
|
缓存 前端开发 Java
Spring日常
Spring日常
一百减一是零
55 1
流烟默
|
7月前
|
Java Spring
Spring中那些BeanFactoryPostProcessors详解（二）
Spring中那些BeanFactoryPostProcessors详解（二）
流烟默
46 0
吉士先生
|
XML Java 数据格式
80.【Spring5】（三）
80.【Spring5】
吉士先生
60 0
yqd666
|
XML 开发框架 Java
Spring详细总结1
1.Spring简介 1.1 Spring概述 （1）Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用Spring 框架 来创建性能好(spring为我们提供对象的创建)、易于测试(整合了Junit)、可重用的代码(例如把事务的代码放到切面中， 再把切面作用于方法中)。
yqd666
198 0
Spring详细总结1
龙哥手记
|
XML Java 数据格式
Spring MessageSource详解
《基础系列》
龙哥手记
359 0
Spring MessageSource详解

热门文章

最新文章

  • 1
    Hadoop迁移MaxCompute神器之DataX-On-Hadoop使用指南
  • 2
    Nginx的启动、停止与重启
  • 3
    Hive之数据倾斜的原因和解决方法
  • 4
    开发人员各级岗位胜任力模型
  • 5
    Node.js 中流操作实践
  • 6
    传奇龙版地图查看器
  • 7
    调整DC的网络对网络是否会有影响?
  • 8
    How to maintain Oracle10g Recyclebin?
  • 9
    你知道自己感染了恶意软件吗？
  • 10
    Groovy 快速入门
  • 1
    Python学习的自我理解和想法（9）
    89
  • 2
    Kimi 上线视觉思考模型，K1 系列强化学习模型正式开放，无需借助外部 OCR 处理图像与文本进行思考并回答
    99
  • 3
    CosyVoice 2.0：阿里开源升级版语音生成大模型，支持多语言和跨语言语音合成，提升发音和音色等的准确性
    78
  • 4
    Megrez-3B-Omni：无问芯穹开源最强端侧全模态模型，支持理解图像、音频和文本三种模态数据
    50
  • 5
    FreeScale：无需微调即可提升模型的图像生成能力，生成 8K 分辨率的高质量图像
    37
  • 6
    Freestyler：微软联合西工大和香港大学推出说唱音乐生成模型，支持控制生成的音色、风格和节奏等
    36
  • 7
    《C 语言与统计假设检验：洞察人工智能模型性能差异》
    82
  • 8
    《C 语言赋能：物联网环境下人工智能应用的能耗优化之道》
    21
  • 9
    《C 语言助力神经网络剪枝：优化模型的卓越之道》
    25
  • 10
    《C 语言复数运算：赋能人工智能信号处理新境界》
    20

    • 相关课程

    更多
  • 5天实战Spring Boot 2.5
  • 5天突破Spring Cloud
  • Spring Boot 2.5.x开发实战
  • 精通Spring Cloud Alibaba
  • Spring Cloud Alibaba Nacos 详解（上）
  • Spring Cloud Alibaba Nacos 详解（下）

    • 相关电子书

    更多
  • Spring Boot 2.5开发实战
  • Java Spring Boot开发实战系列课程【第15讲】：Spring Boot 2.0 API与Spring REST Docs实战
  • Spring Cloud Alibaba 从入门到实战

    • 相关实验场景

    更多
  • Spring-cloud-bus-rocketmq入门与实践
  • Rocketmq-spring入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    fs.oss.accessKeyId和fs.oss.accessKeySecret。