【深入浅出Spring6】第三期——作用域和工厂模式

已于 2022-11-16 08:09:54 修改
阅读量272 收藏 1
点赞数 1
分类专栏： Spring 文章标签： java 单例模式 开发语言
于 2022-11-15 23:33:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61323055/article/details/127853602
版权

一、Bean 的作用域

  • 作用域以下用 scope 代替，在不同的应用情景下可以使用的参数值下是不同的
  • 我们以普通 Java 工程为例：可选的参数值有两个 singleton、prototype

$ singleton

  • 默认情况下，scope 的属性值就为 singleton,当然我们也可以显式的定义为 singleton
  • 需求：我们想测试以前之前创建的bean对象是单例还是多例的

编写我们待测试的Bean类 SpringBean.java

package com.powernode.spring6.bean;

/**
 * @author Bonbons
 * @version 1.0
 */
public class SpringBean {
    public SpringBean(){
        System.out.println("调用了无参构造方法");
    }
}

我们之前就知道，Spring创建对象是在初始化上下文的时候进行的，而且调用了无参构造方法，此处我们直接给出无参构造方法，方便更好的说明问题

编写我们的 spring 配置文件 spring-scope.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-->
    <bean id="sb" class="com.powernode.spring6.bean.SpringBean"/>
</beans>

编写测试方法，利用getBean方法多次获取我们的Bean对象

@Test
    public void testBeanScope(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-scope.xml");
        SpringBean sb = applicationContext.getBean("sb", SpringBean.class);
        System.out.println(sb);

        SpringBean sb2 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println(sb2);

        SpringBean sb3 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println(sb3);

        /**
         * 测试结果，输出的三个bean是一个对象
         * 原因：
         *    在我们解析XML配置文件的时候，对象就已经调用无参构造方法创建结束了
         *    在我们调用getBean的时候得到的就是已经创建好的对象，默认情况下是单例模式的
         */
    }

在这里插入图片描述

  • 通过测试结果我们可以发现，无参构造方法只被调用一次，而且通过getBean方法获取到的对象都是同一个实例
  • 得出结论：默认情况下我们创建的Bean对象的单例的
  • Bean对象的创建是在初始化Spring上下文的时候就完成的。
  • 那么如果我们想通过getBean获得不同的对象，我们应该怎么做呢？

$ prototype

  • 单词的含义为原型、多例，我们可以将scope的属性值定义为 prototype 来解决上面的问题
  • 我们修改一下配置文件的那条bean定义语句,并再次运行测试文件
<bean id="sb" class="com.powernode.spring6.bean.SpringBean" scope="prototype"/>

在这里插入图片描述

  • 我们可以发现，调用了三次无参构造方法，我们获得的是三个不同的Bean的对象

  • 我们在使用默认的作用域时，无论是否调用getBean方法，都会调用我们Bean类的无参构造方法，但是当我们将作用域定义为 prototype 的时候，如果没有调用getBean方法就不会去调用无参构造方法

$ 其他 scope

  • 其实我们Bean 的作用域并不是只有两个，但是有些作用域只有在特定的情景下才会有效

  • 那么Bean的作用域都包括哪些呢？
    在这里插入图片描述

  • 尽管自定义的 scope 很少使用，但是我们还是给出如果来自定义 scope？

  • 需求：我们先测试一下，不同线程创建的Bean是单例的还是多列的？

还是利用我们上面的文件，只是在测试方法处创建新的线程进而再获得实例 【scope采用默认值】

 @Test
    public void testThreadScope(){
        // 获得一个SpringBean的实例
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-scope.xml");
        SpringBean sb1 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println(sb1);

        SpringBean sb2 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println(sb2);
        // 创建一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                SpringBean sb3 = applicationContext.getBean("sb", SpringBean.class);
                System.out.println(sb3);
            }
        }).start();
    }

经过前面在 singleton 部分的测试我们知道，sb1和sb2一定是同一个对象，那么到底不同线程的bean是单例的还是多例的呢？

在这里插入图片描述

  • 很显然，不同线程获得的Bean仍然是单例的
  • 我们想自定义一个scope，实现不同线程获得的是不同的Bean的实例

（1）我们自定义一个Scope类，实现Scope接口

  • spring内置了线程范围的类：org.springframework.context.support.SimpleThreadScope，可以直接用

（2）将我们自定义的Scope注册到Spring容器中 【此处我们直接就定义到了上面的 spring-scope.xml中】

<!--配置我们自定义的scope-->
    <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
        <property name="scopes">
            <map>
                <entry key="threadScope">
                    <bean class="org.springframework.context.support.SimpleThreadScope" />
                </entry>
            </map>
        </property>
    </bean>

（3）想要使用我们的这个scope只需在声明bean的时候将scope属性的值设置为我们自定义的scope即可

<!-使用我们自定义的scope-->
<bean id="sb" class="com.powernode.spring6.bean.SpringBean" scope="threadScope"/>

（4）再次测试我们上面那个不同线程获得的bean对象是否为同一个

@Test
    public void testThreadScope(){
        // 获得一个SpringBean的实例
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-scope.xml");
        SpringBean sb1 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println(sb1);

        SpringBean sb2 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println(sb2);
        // 创建一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                SpringBean sb3 = applicationContext.getBean("sb", SpringBean.class);
                System.out.println(sb3);
            }
        }).start();
    }

在这里插入图片描述
通过结果我们可以看到，已经实现了不同线程通过getBean方法获得的bean的对象不是同一个

二、GoF 工厂模式

  • GoF 的中文含义代表四人组（指的是编写设计模式的四个作者）

  • 设计模式：可以重复利用的一种解决问题的方案，该书中包含 23 种设计模式，当然也存在其他的设计模式

  • GoF 23种设计模式可以分为三大类：

    • 创建型：解决对象创建问题
      • 单例模式
      • 工厂方法模式
      • 抽象工厂模式
      • 建造者模式
      • 原型模式
    • 结构型：一些类或对象组合在一起的经典结构
      • 代理模式
      • 装饰模式
      • 适配器模式
      • 组合模式
      • 享元模式
      • 外观模式
      • 桥接模式
    • 行为型：解决类或对象之间的交互问题
      • 策略模式
      • 模板方法模式
      • 责任链模式
      • 观察者模式
      • 迭代子模式
      • 命名模式
      • 备忘录模式
      • 状态模式
      • 访问者模式
      • 中介者模式
      • 解释器模式

  • 因为Spring容器使用了大量的工厂模式，所以接下来我们对工厂模式展开论述

$ 工厂模式的三种形态

  • 简单工厂模式（静态工厂模式）：是工厂方法模式的一种特殊形式
  • 工厂方法模式：GoF 设计模式的一种
  • 抽象工厂模式：GoF 设计模式的一种

$ 简单工厂模式

  • 简单工厂模式的角色有三个：
    • 抽象产品角色
    • 具体产品角色
    • 工厂类角色
  • 需求：我们通过编写对应角色的文件，来演示简单工厂模式究竟是怎样的？

编写抽象产品角色，抽象类 + 抽象方法 Weapon.java

package com.powernode.simple.factory;

/**
 * 抽象产品角色
 * @author Bonbons
 * @version 1.0
 */
public abstract class Weapon {
    // 定义一个抽象的攻击方法，具体内容由其子类去实现
    public abstract void attack();
}

编写具体产品角色，此处我们就给两个 Tank.java、Dagger.java 要继承我们的抽象产品角色并实现抽象方法

package com.powernode.simple.factory;

/**
 * 具体产品角色
 * @author Bonbons
 * @version 1.0
 */
public class Tank extends Weapon{
    @Override
    public void attack() {
        System.out.println("向我开炮!!!");
    }
}

package com.powernode.simple.factory;

/**
 * 具体产品角色
 * @author Bonbons
 * @version 1.0
 */
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("偷袭!!!");
    }
}

编写工厂类角色，WeaponFactory 类提供一个静态方法，根据我们客户端传递的参数，来决定生成哪个具体的产品角色对象

package com.powernode.simple.factory;

/**
 * 工厂类角色
 * @author Bonbons
 * @version 1.0
 */
public class WeaponFactory {
    /**
     * 简单工厂模式我们又称之为静态工厂模式：
     * 通过一个静态方法，根据我们的参数生成对应的具体产品角色的对象
     */

    public static Weapon get(String weapon){
        // 通过if条件判断去匹配对应的角色
        if("TANK".equals(weapon)){
            return new Tank();
        }else if("FIGHTER".equals(weapon)){
            return new Fighter();
        }else if("DAGGER".equals(weapon)){
            return new Dagger();
        }else{
            throw new RuntimeException("无法识别该类型!!!");
        }
    }
}

编写Test测试方法：

package com.powernode.simple.factory;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Test {
    public static void main(String[] args) {

        // 如果我们需要坦克
        Weapon tank = WeaponFactory.get("TANK");
        tank.attack();

        // 如果我们需要偷袭
        Weapon dagger = WeaponFactory.get("DAGGER");
        dagger.attack();
    }
}

在这里插入图片描述

  • Spring 中的BeanFactory就采用了简单工厂模式

  • 简单工厂模式的优点：

    • 实现了责任的分离，工厂负责生产，客户端负责消费
    • 客户端程序不必关系对象创建的细节，想要创建哪个对象就传入对应的参数即可

  • 简单工厂模式的缺点：

    • 需要扩展新产品时，需要修改WeaponFactory类，违背了OCP开闭原则
    • 工厂类负责生产所有的产品，一旦出现问题就会导致全盘崩溃

$ 工厂方法模式

  • 工厂方法模式的角色对象有四个：【改变就是让一个具体的工厂去生产一种具体的产品】
    • 抽象产品角色
    • 具体产品角色
    • 抽象工厂角色
    • 具体工厂角色
  • 需求：我们创建一个新的模块还是通过实践演示工厂方法模式的原理是怎样的

创建一个新模块 factory-method 并不需要添加依赖什么的，因为这部分的内容用不到

编写我们的抽象产品角色 >> Weapon

package com.powernode.factory.method;

/**
 * 抽象产品角色
 * @author Bonbons
 * @version 1.0
 */
abstract public class Weapon {
    public abstract void attack();
}

编写我们的具体产品角色 >> Gun、Dagger

package com.powernode.factory.method;

/**
 * 具体产品角色
 * @author Bonbons
 * @version 1.0
 */
public class Gun extends Weapon{

    @Override
    public void attack() {
        System.out.println("开枪射击!!!");
    }
}

package com.powernode.factory.method;

/**
 * 具体产品角色
 * @author Bonbons
 * @version 1.0
 */
public class Dagger extends Weapon{

    @Override
    public void attack() {
        System.out.println("给你一刀!!!");
    }
}

编写我们的抽象工厂 >> WeaponFactory

package com.powernode.factory.method;

/**
 * 抽象工厂角色
 * @author Bonbons
 * @version 1.0
 */
abstract public class WeaponFactory {
    // 给出获得工厂对象的get方法，具体获得哪个工厂的对象由实现它的工厂决定
    public abstract Weapon get();
}

编写我们的具体工厂角色 >> GunFactory、DaggerFactory

package com.powernode.factory.method;

/**
 * 具体工厂角色
 * @author Bonbons
 * @version 1.0
 */
public class GunFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Gun();
    }
}

package com.powernode.factory.method;

/**
 * 具体工厂角色
 * @author Bonbons
 * @version 1.0
 */
public class DaggerFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Dagger();
    }
}

编写我们的测试方法

package com.powernode.factory.method;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 我们先获得想要的工厂
        WeaponFactory daggerFactory = new DaggerFactory();
        // 调用工厂的get方法，就可以获得对应工厂的产品
        Weapon dagger = daggerFactory.get();
        // 然后我们调用我们产品的方法
        dagger.attack();

        WeaponFactory gunFactory = new GunFactory();
        Weapon gun = gunFactory.get();
        gun.attack();
    }
}

在这里插入图片描述

  • 工厂方法模式的优点：

    • 如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，解决了简单工厂模式的OCP问题
    • 扩展性高，为用户提供接口，屏蔽了产品的具体实现

  • 工厂方法模式的缺点：

    • 我们添加一个新产品就要添加具体的产品角色和具体的工厂角色，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

$ 抽象工厂模式

  • 如何理解抽象工厂模式？

    • 工厂方法模式对应一个系列，抽象工厂模式就对应多个系列
    • 工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果
    • 抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象

  • 抽象工厂模式的组成：

    • 抽象工厂角色
    • 具体工厂角色
    • 抽象产品角色
    • 具体产品角色

  • 需求：我们写一个案例，包含两个系列——武器系列和水果系列

编写武器产品系列: 一个抽象产品角色、两个具体产品角色

package com.powernode.product;

/**
 * 武器产品族
 * @author 动力节点
 * @version 1.0
 * @className Weapon
 * @since 1.0
 **/
public abstract class Weapon {
    public abstract void attack();
}

package com.powernode.product;

/**
 * 武器产品族中的产品等级1
 * @author 动力节点
 * @version 1.0
 * @className Gun
 * @since 1.0
 **/
public class Gun extends Weapon{
    @Override
    public void attack() {
        System.out.println("开枪射击！");
    }
}

package com.powernode.product;

/**
 * 武器产品族中的产品等级2
 * @author 动力节点
 * @version 1.0
 * @className Dagger
 * @since 1.0
 **/
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("砍丫的！");
    }
}

编写水果产品系列: 一个抽象产品角色、两个具体产品角色

package com.powernode.product;

/**
 * 水果产品族
 * @author 动力节点
 * @version 1.0
 * @className Fruit
 * @since 1.0
 **/
public abstract class Fruit {
    /**
     * 所有果实都有一个成熟周期。
     */
    public abstract void ripeCycle();
}

package com.powernode.product;

/**
 * 水果产品族中的产品等级1
 * @author 动力节点
 * @version 1.0
 * @className Orange
 * @since 1.0
 **/
public class Orange extends Fruit{
    @Override
    public void ripeCycle() {
        System.out.println("橘子的成熟周期是10个月");
    }
}

package com.powernode.product;

/**
 * 水果产品族中的产品等级2
 * @author 动力节点
 * @version 1.0
 * @className Apple
 * @since 1.0
 **/
public class Apple extends Fruit{
    @Override
    public void ripeCycle() {
        System.out.println("苹果的成熟周期是8个月");
    }
}

编写我们的抽象工厂角色

package com.powernode.factory;

import com.powernode.product.Fruit;
import com.powernode.product.Weapon;

/**
 * 抽象工厂
 * @author 动力节点
 * @version 1.0
 * @className AbstractFactory
 * @since 1.0
 **/
public abstract class AbstractFactory {
    public abstract Weapon getWeapon(String type);
    public abstract Fruit getFruit(String type);
}

编写我们的具体工厂角色 >> 采用简单工厂的方式实现的

package com.powernode.factory;

import com.powernode.product.Dagger;
import com.powernode.product.Fruit;
import com.powernode.product.Gun;
import com.powernode.product.Weapon;

/**
 * 武器族工厂
 * @author 动力节点
 * @version 1.0
 * @className WeaponFactory
 * @since 1.0
 **/
public class WeaponFactory extends AbstractFactory{

    public Weapon getWeapon(String type){
        if (type == null || type.trim().length() == 0) {
            return null;
        }
        if ("Gun".equals(type)) {
            return new Gun();
        } else if ("Dagger".equals(type)) {
            return new Dagger();
        } else {
            throw new RuntimeException("无法生产该武器");
        }
    }

    @Override
    public Fruit getFruit(String type) {
        return null;
    }
}

package com.powernode.factory;

import com.powernode.product.*;

/**
 * 水果族工厂
 * @author 动力节点
 * @version 1.0
 * @className FruitFactory
 * @since 1.0
 **/
public class FruitFactory extends AbstractFactory{
    @Override
    public Weapon getWeapon(String type) {
        return null;
    }

    public Fruit getFruit(String type){
        if (type == null || type.trim().length() == 0) {
            return null;
        }
        if ("Orange".equals(type)) {
            return new Orange();
        } else if ("Apple".equals(type)) {
            return new Apple();
        } else {
            throw new RuntimeException("我家果园不产这种水果");
        }
    }
}

编写我们的客户端测试程序：

package com.powernode.client;

import com.powernode.factory.AbstractFactory;
import com.powernode.factory.FruitFactory;
import com.powernode.factory.WeaponFactory;
import com.powernode.product.Fruit;
import com.powernode.product.Weapon;

/**
 * @author 动力节点
 * @version 1.0
 * @className Client
 * @since 1.0
 **/
public class Client {
    public static void main(String[] args) {
        // 客户端调用方法时只面向AbstractFactory调用方法。
        AbstractFactory factory = new WeaponFactory(); // 注意：这里的new WeaponFactory()可以采用 简单工厂模式 进行隐藏。
        Weapon gun = factory.getWeapon("Gun");
        Weapon dagger = factory.getWeapon("Dagger");

        gun.attack();
        dagger.attack();

        AbstractFactory factory1 = new FruitFactory(); // 注意：这里的new FruitFactory()可以采用 简单工厂模式 进行隐藏。
        Fruit orange = factory1.getFruit("Orange");
        Fruit apple = factory1.getFruit("Apple");

        orange.ripeCycle();
        apple.ripeCycle();
    }
}

抽象工厂模式的优缺点：

  • 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
  • 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在AbstractFactory里加代码，又要在具体的里面加代码 【违背了OCP原则】
Bow.贾斯汀
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring 6【什么是Spring 6、Spring框架介绍 、Spring IoC/DI 详解 】(一)-全面详解（学习总结---从入门到深化）
07-16 3085
Spring 6【什么是Spring 6、Spring框架介绍、Spring IoC/DI 详解】(一)-全面详解（学习总结---从入门到深化）
Spring从入门到入土——Bean的作用域
12-20
Bean的作用域Bean的作用...Spring从入门到入土——Bean的作用域 Bean的作用域 ​ 在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的
Spring6全面详解
weixin_45710998的博客
03-01 3419
　 自2022年11月，Spring6正式发布。在Spring6中，对于JDK的要求最低为 17+。（17 - 19） 部分文本摘抄于尚硅谷视频（bilibili）做了一定的排版和个人的理解。如果不是很熟悉，可以去看 [Spring5全面详解](http://t.csdn.cn/FgTQ7) 内容大约十万字左右， 对于Spring5的使用整理的较为全面，也都有解释部分，Spring6只是看以下是否具有一些特性上的更换。所以可能并没有Spring5的内容详细。但本篇大约在8-10万字左右。
Spring6详解-概述，入门
最新发布
qq_33934592的博客
03-12 831
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。
Spring6
qq_52922453的博客
06-05 658
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。
Spring系列：Spring6简介和基本使用
程序人生
11-06 204
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。
浅谈spring中scope作用域
08-28
主要介绍了浅谈spring中scope作用域，具有一定借鉴价值，需要的朋友可以参考下。
深入了解Spring中Bean的作用域和生命周期
08-25
主要介绍了深入了解Spring中Bean的作用域和生命周期,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
深入浅出学spring
05-21
本视频从基础讲起，对spring初学者的帮助还是比较大的
Spring实战之Bean的作用域request用法分析
08-25
主要介绍了Spring实战之Bean的作用域request用法,结合实例形式分析了spring中Bean的request作用域相关使用技巧与操作注意事项,需要的朋友可以参考下
spring6（概念；ioc详解，各种数据的注入方式）
m0_64589497的博客
12-29 1705
概念；ioc详解，各种数据的注入方式
spring6
UntifA的博客
06-06 757
spring6
Spring6.0全新发布，快来看看
Jan's的博客
10-25 6431
的第二个里程碑和对应的Spring Boot 3.0第一个里程碑将和大家见面。的代理机制将失效， 请为此类控制器启用基于类的代理。的持久层规范也将在此次里程碑版本中完成迁移。此外，团队称预估整体的项目在11月正式 GA。），以及对其他基础设施的修改。也并非新的技术，前身是Java的J2EE。在本次里程碑版本中涉及到的两个核心容器规范。作为重大更新，他直接舍弃一以往版本的。不是什么新技术，那么由来在这说一下。的组件已经在本次里程碑版本中移除。之前默认情况以下代码是可以的。是目前里程碑版本的基准线。
Spring6的新特性，正式“抛弃”feign了！
Java精选
01-28 2097
多数网友在对接第三方系统时，还在使用 httpclient、okhttp 等方式进行硬编码的形式实现对接。其实，我认为使用 feign 来实现更为方便快捷。feign 除了服务间的 http 调用外，还支持非服务间的 http 调用。只是，我们的一些思维还未转变过来，对 feign 的底层实现也缺乏一定的了解。近期，Spring 6 的第一个 GA 版本发布了，其中带来了一个新的特性——HTTP ...
spring6概述
m0_62946761的博客
09-26 3397
介绍spring6以及进行入门，包括加入log4j日志等
Spring6 正式发布！重磅更新，是否可以拯救 Java
宋小生-中间件
12-05 3172
Spring Framework6 和 Spring Boot3 是一个跨越式的升级整个框架支持的最低 JDK 版本直接跨越到 JDK17，无论框架层还是基础设施层都做了巨大的改变，Spring 6.0 新框架具体做了哪些功能的升级与改进，是否有必要升级与使用呢？可以继续看一看。下面可以先看下翻译自 Spring 官方社区一个宣导博客尊敬的 Spring 社区：我很高兴地宣布，现在 MavenCentral 已经可以提供 SpringFramework6.0.0 了！这是 2023 年及以后新一代框架的开始
2023新版Spring6全新讲解-HelloSpring入门案例
波波烤鸭的博客
05-23 1031
Spring入门案例详解
深入浅出SpringSecurity的pdf
05-31
很抱歉，我无法为您提供深入浅出Spring Security的PDF文件。作为一个AI语言模型，我不能提供或分享任何侵犯版权的内容。不过，您可以通过搜索引擎或者在线学习平台寻找相关的学习资料，例如Spring官方文档或者Spring...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bow.贾斯汀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值