Spring6复习（1）

已于 2023-05-10 21:59:28 修改
阅读量55 收藏
点赞数 1
文章标签： spring java mybatis
于 2023-05-10 21:41:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75274193/article/details/130608945
版权

一、第一个Spring程序

第一步：添加spring context的依赖，pom.xml配置如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.powernode</groupId>
    <artifactId>spring6-001-first</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

    <dependencies>
        <!--spring context依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0-M2</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

</project>

当加入spring context的依赖之后，会关联引入其他依赖：

spring aop：面向切面编程

spring beans：IoC核心

spring core：spring的核心工具包

spring jcl：spring的日志包

spring expression：spring表达式

第二步：添加junit依赖

第三步：定义bean：User

package com.powernode.spring6.bean;

/**
 * bean，封装用户信息。
 * @author 动力节点
 * @version 1.0
 * @since 1.0
 */
public class User {
}

第四步：编写spring的配置文件：beans.xml。该文件放在类的根路径下。

beans.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="userBean" class="com.powernode.spring6.bean.User"/>
</beans>

bean的id和class属性：

  • id属性：代表对象的唯一标识。可以看做一个人的身份证号。
  • class属性：用来指定要创建的java对象的类名，这个类名必须是全限定类名（带包名）。

第五步：编写测试程序

Spring6Test.java

package com.powernode.spring6.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Spring6Test {

    @Test
    public void testFirst(){
        // 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        // 根据id获取bean对象
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);
    }
}

Spring入门程序注意事项

1. OCP开闭原则
    * 什么是OCP？
        OCP是软件七大开发原则当中最基本的一个原则：开闭原则
        对什么开？对扩展开放。
        对什么闭？对修改关闭。
    * OCP原则是最核心的，最基本的，其他的六个原则都是为这个原则服务的。
    * OCP开闭原则的核心是什么？
        只要你在扩展系统功能的时候，没有修改以前写好的代码，那么你就是符合OCP原则的。
        反之，如果在扩展系统功能的时候，你修改了之前的代码，那么这个设计是失败的，违背OCP原则。
    * 当进行系统功能扩展的时候，如果动了之前稳定的程序，修改了之前的程序，之前所有程序都需要进行重新测试。这是不想看到的，因为非常麻烦。

2. 依赖倒置原则（DIP原则）
    * 什么是依赖倒置原则？
        面向接口编程，面向抽象编程，不要面向具体编程。
    * 依赖倒置原则的目的？
        降低程序的耦合度，提高扩展力。
    * 什么叫做符合依赖倒置？
        上 不依赖 下，就是符合。
    * 什么叫做违背依赖倒置？
        上 依赖 下，就是违背。
        只要“下”一改动，“上”就受到牵连。

3. 当前程序的设计，显然既违背OCP，又违背DIP，怎么办？
    可以采用“控制反转”这种编程思想来解决这个问题。

4. 什么是控制反转？
    控制反转：IoC（Inversion of Control）
    反转是什么呢？
        反转的是两件事：
            第一件事：我不在程序中采用硬编码的方式来new对象了。（new对象我不管了，new对象的权利交出去了。）
            第二件事：我不在程序中采用硬编码的方式来维护对象的关系了。（对象之间关系的维护权，我也不管了，交出去了。）

    控制反转：是一种编程思想。或者叫做一种新型的设计模式。由于出现的比较新，没有被纳入GoF23种设计模式范围内。

5. Spring框架
    * Spring框架实现了控制反转IoC这种思想
        Spring框架可以帮你new对象。
        Spring框架可以帮你维护对象和对象之间的关系。
    * Spring是一个实现了IoC思想的容器。
    * 控制反转的实现方式有多种，其中比较重要的叫做：依赖注入(Dependency Injection，简称DI)。
    * 控制反转是思想。依赖注入是这种思想的具体实现。
    * 依赖注入DI，又包括常见的两种方式：
        第一种：set注入（执行set方法给属性赋值）
        第二种：构造方法注入（执行构造方法给属性赋值）
    * 依赖注入 中 “依赖”是什么意思？ “注入”是什么意思？
        依赖：A对象和B对象的关系。
        注入：是一种手段，通过这种手段，可以让A对象和B对象产生关系。
        依赖注入：对象A和对象B之间的关系，靠注入的手段来维护。而注入包括：set注入和构造注入。
6. 注意术语：
    OCP：开闭原则（开发原则）
    DIP：依赖倒置原则（开发原则）
    IoC：控制反转（一种思想，一种新型的设计模式）
    DI：依赖注入（控制反转思想的具体实现方式）

二、Spring对IoC的实现

2.1 IoC 控制反转

  • 控制反转是一种思想。
  • 控制反转是为了降低程序耦合度，提高程序扩展力，达到OCP原则，达到DIP原则。
  • 控制反转，反转的是什么？
    • 将对象的创建权利交出去，交给第三方容器负责。
    • 将对象和对象之间关系的维护权交出去，交给第三方容器负责。
  • 控制反转这种思想如何实现呢？
    • DI（Dependency Injection）：依赖注入

2.2 依赖注入

依赖注入实现了控制反转的思想。

Spring通过依赖注入的方式来完成Bean管理的。

Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。

依赖注入：

  • 依赖指的是对象和对象之间的关联关系。
  • 注入指的是一种数据传递行为，通过注入行为来让对象和对象产生关系。

依赖注入常见的实现方式包括两种：

  • 第一种：set注入
  • 第二种：构造注入

2.2.1 set注入

set注入，基于set方法实现的，底层会通过反射机制调用属性对应的set方法然后给属性赋值。这种方式要求属性必须对外提供set方法。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.powernode</groupId>
    <artifactId>spring6-002-dependency-injection</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0-M2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

</project>

UserDao

package com.powernode.spring6.dao;

/**
 * @author 动力节点
 * @version 1.0
 * @className UserDao
 * @since 1.0
 **/
public class UserDao {

    public void insert(){
        System.out.println("正在保存用户数据。");
    }
}

UserService

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className UserService
 * @since 1.0
 **/
public class UserService {

    private UserDao userDao;

    // 使用set方式注入，必须提供set方法。
    // 反射机制要调用这个方法给属性赋值的。
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

spring.xml

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

    <bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

    <!--
        name指定的是set方法去掉set后首字母小写的属性名。
        ref指定参数对应的bean的id。
        name为set方法名去掉set，然后首字母转为小写。
    -->
    <bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
        <property name="userDao" ref="userDaoBean"/>
    </bean>

</beans>

DITest.java

package com.powernode.spring6.test;

import com.powernode.spring6.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 动力节点
 * @version 1.0
 * @className DITest
 * @since 1.0
 **/
public class DITest {

    @Test
    public void testSetDI(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = applicationContext.getBean("userServiceBean", UserService.class);
        userService.save();
    }
}

2.2.2 构造注入

核心原理：通过调用构造方法来给属性赋值

OrderDao

package com.powernode.spring6.dao;

/**
 * @author 动力节点
 * @version 1.0
 * @className OrderDao
 * @since 1.0
 **/
public class OrderDao {
    public void deleteById(){
        System.out.println("正在删除订单。。。");
    }
}

OrderService

package com.powernode.spring6.service;

import com.powernode.spring6.dao.OrderDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className OrderService
 * @since 1.0
 **/
public class OrderService {
    private OrderDao orderDao;

    // 通过反射机制调用构造方法给属性赋值
    public OrderService(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

    public void delete(){
        orderDao.deleteById();
    }
}

spring.xml

<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>
<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--index="0"表示构造方法的第一个参数，将orderDaoBean对象传递给构造方法的第一个参数。-->
  <constructor-arg index="0" ref="orderDaoBean"/>
</bean>

测试程序

@Test
public void testConstructorDI(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    OrderService orderServiceBean = applicationContext.getBean("orderServiceBean", OrderService.class);
    orderServiceBean.delete();
}

此外：

通过测试得知，通过构造方法注入的时候：

  • 可以通过下标
  • 可以通过参数名
  • 也可以不指定下标和参数名，可以类型自动推断。

Spring在装配方面做的还是比较健壮的。

简单类型注入

通过源码分析得知，简单类型包括：

  • 基本数据类型
  • 基本数据类型对应的包装类
  • String或其他的CharSequence子类
  • Number子类
  • Date子类
  • Enum子类
  • URI
  • URL
  • Temporal子类
  • Locale
  • Class
  • 另外还包括以上简单值类型对应的数组类型。
  • 需要注意的是：
  • 如果把Date当做简单类型的话，日期字符串格式不能随便写。格式必须符合Date的toString()方法格式。显然这就比较鸡肋了。如果我们提供一个这样的日期字符串：2010-10-11，在这里是无法赋值给Date类型的属性的。
  • spring6之后，当注入的是URL，那么这个url字符串是会进行有效性检测的。如果是一个存在的url，那就没问题。如果不存在则报错。

  • 2.4 p命名空间注入

  • 目的：简化配置。使用p命名空间注入的前提条件包括两个：

    第一：在XML头部信息中添加p命名空间的配置信息：xmlns:p="http://www.springframework.org/schema/p"
  • 第二：p命名空间注入是基于setter方法的，所以需要对应的属性提供setter方法。

Customer

package com.powernode.spring6.beans;

/**
 * @author 动力节点
 * @version 1.0
 * @className Customer
 * @since 1.0
 **/
public class Customer {
    private String name;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }

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

spring-p.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="customerBean" class="com.powernode.spring6.beans.Customer" p:name="zhangsan" p:age="20"/>

</beans>

测试程序

@Test
public void testP(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-p.xml");
    Customer customerBean = applicationContext.getBean("customerBean", Customer.class);
    System.out.println(customerBean);
}

2.5 c命名空间注入

c命名空间是简化构造方法注入的。

使用c命名空间的两个前提条件：

第一：需要在xml配置文件头部添加信息：xmlns:c="http://www.springframework.org/schema/c"

第二：需要提供构造方法。

MyTime

package com.powernode.spring6.beans;

/**
 * @author 动力节点
 * @version 1.0
 * @className MyTime
 * @since 1.0
 **/
public class MyTime {
    private int year;
    private int month;
    private int day;

    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyTime{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

spring-c

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/c"
       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="myTimeBean" class="com.powernode.spring6.beans.MyTime" c:year="1970" c:month="1" c:day="1"/>-->

    <bean id="myTimeBean" class="com.powernode.spring6.beans.MyTime" c:_0="2008" c:_1="8" c:_2="8"/>

</beans>

测试程序

@Test
public void testC(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-c.xml");
    MyTime myTimeBean = applicationContext.getBean("myTimeBean", MyTime.class);
    System.out.println(myTimeBean);
}

2.6 util命名空间

使用util命名空间可以让配置复用。

使用util命名空间的前提是：在spring配置文件头部添加配置信息。如下：

spring-util.xml

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

    <util:properties id="prop">
        <prop key="driver">com.mysql.cj.jdbc.Driver</prop>
        <prop key="url">jdbc:mysql://localhost:3306/spring</prop>
        <prop key="username">root</prop>
        <prop key="password">123456</prop>
    </util:properties>

    <bean id="dataSource1" class="com.powernode.spring6.beans.MyDataSource1">
        <property name="properties" ref="prop"/>
    </bean>

    <bean id="dataSource2" class="com.powernode.spring6.beans.MyDataSource2">
        <property name="properties" ref="prop"/>
    </bean>
</beans>

2.7 基于XML的自动装配

Spring还可以完成自动化的注入，自动化注入又被称为自动装配。它可以根据名字进行自动装配，也可以根据类型进行自动装配。

2.8 Spring引入外部属性配置文件 

我们都知道编写数据源的时候是需要连接数据库的信息的，例如：driver url username password等信息。这些信息可以单独写到一个属性配置文件中吗，这样用户修改起来会更加的方便。当然可以。

第一步：写一个数据源类，提供相关属性。

package com.powernode.spring6.beans;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

/**
 * @author 动力节点
 * @version 1.0
 * @className MyDataSource
 * @since 1.0
 **/
public class MyDataSource implements DataSource {
    @Override
    public String toString() {
        return "MyDataSource{" +
                "driver='" + driver + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    private String driver;
    private String url;
    private String username;
    private String password;

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //......
}

第二步：在类路径下新建jdbc.properties文件，并配置信息。

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/spring
username=root
password=root123

第三步：在spring配置文件中引入context命名空间。

第四步：在spring中配置使用jdbc.properties文件。

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

    <context:property-placeholder location="jdbc.properties"/>
    
    <bean id="dataSource" class="com.powernode.spring6.beans.MyDataSource">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
    </bean>
</beans>

测试程序

@Test
public void testProperties(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-properties.xml");
    MyDataSource dataSource = applicationContext.getBean("dataSource", MyDataSource.class);
    System.out.println(dataSource);
}

淳平讲Java
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring boot 复习资料
04-08
spring boot 复习资料
spring学习复习资料
09-24
java spring的学习资料
spring复习
qq_44892120的博客
12-17 1409
spring复习 spring复习一、spring简介1.Spring 中常用术语：2、Spring 的优势3、spring能帮我们做什么4、spring框架的结构二、IOC容器1.首先聊聊控制反转2.生活举例3.构造器注入4.set 方法注入5.Bean的作用域6.自动装配6.1、按照名字自动装配6.2、按照类型自动装配7.注解开发（常用）准备工作使用注解常用的注解第一组，自动装配第二组，分层开发第三组，组件开发第四组，配置文件8.生命周期9.懒加载三、AOP1.什么是AOP2.AOP的相关名词3.练习
spring面试复习-0715
qq_51131591的博客
07-17 867
spring面试复习-0715
Spring突击复习
蜕变
06-21 124
1、SpringIOC 2、Spring显式和隐式的配置Bean 3、从Spring容器中获取Bean对象 4、Bean的作用域 5、依赖注入 @Autowired和@Resource 6、Bean的生命周期
Spring Boot复习
恩琪
08-21 623
一. 什么是SpringBoot Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的创建、运行、调试、部署等。使用Spring Boot可以做到专注于Spring应用的开发，而无需过多关注XML的配置。Spring Boot使用“习惯优于配置”的理念，简单来说，它提供了一堆依赖打包，并已经按照使用习惯解决了依赖问题。使用Spring Boot可以不用或者只需要很少的Spring配置就可以让企业项目快速运行起来。 Spring Boot是开发者和Spring 本
Spring框架复习整理
SmileCoder
10-24 102
Spring框架学习过程内容整理 1、Spring框架相关概述 2、核心思想IoC、AoP 3、Spring框架基础应用和源码分析 4、 Spring AoP剖析 4、Spring事务
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 20万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
Spring复习—MapperScannerConfigurer
weixin_57128596的博客
03-14 2298
介绍和场景 MapperSacnnerConfigurer是Spring和Mybatis整合的jar包中的一个类 <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.5</version> .
Spring复习-问题回答
weixin_63541561的博客
01-23 975
当应用程序中的方法被标记为需要事务管理时，在方法执行前，Spring 会创建一个代理对象，并在代理对象中织入事务管理的逻辑。调用目标类中的方法也就是非业务代码，提高了代码的复用率和灵活性，提高开发效率，降低了非业务代码与业务代码的耦合性。DI是IOC的具体实现，通过依赖注入的方式实现对象之间的解耦，依赖注入可以通过构造函数、setter 方法或字段注入的方式实现。bean是将对象的管理权限交给了Spring容器，而new对象是创建新的对象，同一个类中,使用非代理对象调用一个有事务的方法，导致事务错误。
Java复习05 Spring 概念
weixin_47558943的博客
03-18 1791
程序员告诉Spring他们需要什么样的组件（比如骑士或巫师，或者在编程中可能是一个用来保存数据的组件，或者是处理用户输入的组件），然后Spring就会帮助他们“生成”这些组件，并且把它们装备好，准备投入使用。当然，还有其他的框架，它们就像不同品牌的自行车，每一种都有自己的特色和优势，但Spring因为它的实用性和可靠性，在Java世界中就像是最受欢迎的那种自行车。简单来说，Spring让编程像做蛋糕一样变得更简单有趣，你不用每次都从零开始，而是可以用Spring的工具和“食谱”来帮你更快做出好的程序。
Spring复习之Spring的概述
Java学习之乐的博客
07-17 572
今日目录        1.Spring介绍     2.Spring作用     3.Spring起源     4.Spring体系结构     5.Spring的优点   一、Spring  介绍         Spring 是一个开源框架，Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson 创建。简单来说，Spring 是一个...
spring.md复习资料
04-08
spring.md复习资料
spring复习面试个人总结题集
04-12
spring复习面试个人总结题集
Spring总结和复习
03-23
Spring总结
6、Spring之Bean生命周期~创建Bean（2）
sproutBoy的博客
06-10 680
【代码】6、Spring之Bean生命周期~创建Bean（2）
SpringBoot3 整合 Mybatis 完整版
最新发布
northcastle的博客
06-14 247
SpringBoot3 整合 MyBatis 的步骤详细记录
SpringMVC
qq_51866806的博客
06-08 739
SpringMvc连接、请求、响应
门面模式Api网关(SpringCloudGateway)
风止的博客
06-05 1727
当前通过Eureka、Nacos解决了服务注册和服务发现问题，使用Spring Cloud LoadBalance解决了负载均衡的需求，同时借助OpenFeign实现了远程调用。然而，现有的微服务接口都直接对外暴露，容易被外部访问。为保障对外服务的安全性，通常在服务端实现的微服务接口会带有一定的权限校验机制。由于应用拆分成多个微服务，每个微服务都需要实现权限校验逻辑，导致当逻辑需要修改时，需要在多个应用中进行修改，增加了开发人员的负担。⽐如企业管理。
spring cloud复习
09-09
如果你需要复习Spring Cloud的相关知识，你可以访问Spring官网的Spring Cloud页面（https://spring.io/projects/spring-cloud），这个页面上提供了详细的文档和示例代码，可以帮助你更好地理解和掌握Spring Cloud的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值