开发者

Spring框架概述和翻转权限控制方式

开发者 https://www.devze.com 2025-08-19 11:12 出处：网络 作者： LSL666_
目录1.1 Spring框架概述和翻转权限控制对比 Servlet 的核心优势1.2 代码1.2.1 创建项目1.2.2 创建对象1.2.3 注入属性1.2.4 纯注解开发总结1.1 Spring框架概述和翻转权限控制
相关专题：Spring框架概述Spring翻转Spring翻转权限控制
目录
  • 1.1 Spring框架概述和翻转权限控制
    • 对比 Servlet 的核心优势
  • 1.2 代码
    • 1.2.1 创建项目
    • 1.2.2 创建对象
    • 1.2.3 注入属性
    • 1.2.4 纯注解开发
  • 总结

    1.1 Spring框架概述和翻转权限控制

    1.Spring框架是右边框架的父框架。

    Spring框架概述和翻转权限控制方式

    Spring 并非简单的 “父框架”，而是Java 生态中一站式企业级开发解决方案。它通过模块化设计（Core、Context、AOP、TX 等模块 ），为 Servlet 等框架提供底层支撑：

    • Servlet 专注于 “请求 - 响应” 流程，但架构复杂项目时（如分布式、高并发场景 ），需手动管理对象创建、依赖关系，开发效率低。
    • Spring 则通过 IOC（控制反转）、AOP（面向切面编程） 等核心机制，解决 “对象管理复杂”“功能扩展侵入性强” 等问题，覆盖从小型项目到中大型系统的全场景开发，而非局限于 “中大型项目”。

    对比 Servlet 的核心优势

    维度Servlet 开发痛点Spring 解决方案
    对象管理需手动 new 对象，依赖关系混乱IOC 容器自动管理对象生命周期，依赖自动注入
    功能扩展修改核心代码实现扩展（如权限校验）AOP 无侵入式增强，通过 “切面” 动态扩展功能
    架构复杂度应对中大型项目需大量重复编码（事务、日志）模块化组件（@Service/@Repository 等）+ 生态整合（Spring Boot、Cloud ）

    2.Spring的核心功能：

    传统开发中，对象的创建（如 UserService userService = new UserService() ）由开发者手动控制；

    Spring 则通过 “控制反转”，将对象创建、依赖装配的权力转移给框架。开发者只需定义 “需要什么对象”，由 Spring 自动完成 “创建 - 管理 - 注入” 全流程。

    Spring框架概述和翻转权限控制方式

    • IOC是一个容器，Spring 启动时，会扫描配置（注解 / XML ），将标记的类（如 @Component/<bean> ）实例化为对象（Bean），并存储在 IOC 容器 中，每次需要时只用从IOC里面获取

    核心价值：

    • 解耦对象依赖：无需硬编码 new 操作，通过 @Autowired 即可获取容器中的 Bean。
    • 统一生命周期管理：Bean 的创建、初始化、销毁由容器统一控制（如 init-method/@PostConstruct ）。

    Spring框架概述和翻转权限控制方式

    3.Spring对bean的管理

    Spring框架概述和翻转权限控制方式

    Bean 是 Spring 对 “受管对象” 的抽象，即由 IOC 容器创建、管理、注入的对象。它可以是：

    • 业务逻辑类（@Service 标记的 UserService ）
    • 数据访问类（@Repository 标记的 UserDAO ）
    • 工具类（@Component 标记的 CommonUtils ）

    Spring 提供分层语义注解，明确 Bean 的职责（替代通用 @Component ）：

    注解适用场景设计意图
    @Component普通工具类 / 通用组件基础标记，无明确业务分层含义
    @Controller表现层（Web 层）处理 HTTP 请求，封装响应逻辑
    @Service业务层（Service 层）实现业务规则、协调 DAO 与 Controller
    @Repository持久层（DAO 层）封装数据库操作（MyBATis/ORM ）

    注入属性指的是给属性赋值。

    基于xml注入属性的方式有两种，一种是通过get/set方法，一种是通过构造器。

    基于注解的方式注入属性需要用到的注解

    • @Value 用于注入普通类型（String，int，double等类型）
    • @Autowired 默认按类型进行自动装配（引用类型）
    • @Qualifier 不能单独使用必须和@Autowired一起使用，强制使用名称注入
    • @Resource Java提供的注解，也被支持。使用name属性，按名称注入

    总结：Spring 为何是 Java 开发 “必修课”

    1. 生态基石：Spring 不仅是 “框架”，更是 Java 企业级开发的标准化生态（Spring Boot、Cloud、Security 等均基于其扩展 ）。
    2. 解耦与效率：通过 IOC 实现对象解耦，AOP 实现功能无侵入增强，大幅降低中大型项目的维护成本。
    3. 语义化与规范：分层注解（@Controller/@Service ）和注入机制，推动团队代码规范与架构清晰。

    掌握 Spring 核心机制（IOC/Bean 管理 ），是迈向 Java 中大型项目开发的关键一步 —— 它让 “复杂系统开发” 从 “人力堆砌” 变为 “框架驱动”。

    1.2 代码

    1.2.1 创建项目

    新建一个Maven项目

    Spring框架概述和翻转权限控制方式

    什么都不选，直接下一步

    Spring框架概述和翻转权限控制方式

    创建完成，然后在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.qcby</groupId>
    <artifactId>Spring</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

    1.2.2 创建对象

    • new创建对象和基于xml的方式创建对象
    package com.qcby;

public class Demo {
    public void hello(){
        System.out.println("hello world");
    }
}
    package com.qcby;

public class User {
    public void flay(){
        System.out.println("我会飞……");
    }
}

    在resources文件里创建一个Spring.xml文件

    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">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
    <bean id="demo" class="com.qcby.Demo"/>
    <bean id="user" class="com.qcby.User"/>
</beans>
    import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
    }
}
    • 基于注解的方式创建对象

    Bean 名称的默认生成规则：

    当使用@Component、@Service、@Repository、@Controller等注解时，Spring 会自动生成 Bean 名称。

    规则： 将类名首字母小写，例如类名UserService的默认 Bean 名称为userService。

    对于下面代码使用的区别见后文。

    package com.qcby;

import org.springframework.stereotype.Service;

@Service
public class Demo {
    public void hello(){
        System.out.println("hello world");
    }
}
    package com.qcby;

import org.springframework.stereotype.Controller;

@Controller
public class User {
    public void flay(){
        System.out.println("我会飞……");
    }
}
    package com.qcby;

import org.springframework.stereotype.Component;

@Component
public class Cat {
    public void run(){
        System.out.println("猫跑的很快……");
    }
}
    package com.qcby;

import org.springframework.stereotype.Repository;

@Repository
public class Dog {
    public void jump(){
        System.out.println("狗跳的很高");
    }
}
    import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlApplicapythontionContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
    }

    @org.junit.Test
    public void run3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Cat cat = (Cat)context.getBean("cat");
        cat.run();
    }

    @org.junit.Test
    public void run4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Dog dog = (Dog)context.getBean("dog");
        dog.jump();
    }
}
    <?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">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
<!--    <bean id="demo" class="com.qcby.Demo"/>-->
<!--    <bean id="user" class="com.qcby.User"/>-->

    <!-- 扫描com.qcby下有哪些类，获取全类名，方便创建对象-->
    <context:component-scan base-package="com.qcby"/>
</beans>

    1.2.3 注入属性

    • 基于xml的方式
    package com.qcby;


public class Cat {
    //简单类型
    private int age;
    private Integer num;
    private double height;
    private String name;
    private Demo demo;

    public int getAge() {
        return age;
    }

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

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public Demo getDemo() {
        return demo;
    }

    public void setDemo(Demo demo) {
        this.demo = demo;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", num=" + num +
                ", height=" + height +
                ", name='" + name + '\'' +
                ", demo=" + demo +
                '}';
    }

    public void run(){
        System.out.println("猫跑的很快……");
    }
}
    package com.qcby;


import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class Dog {
    //复杂类型
    private int[] arr;
    private List<String> list;
    private Map<String,String> map;

    public int[] getArr() {
        return arr;
    }

    public void setArr(int[] arr) {
        this.arr = arr;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "arr=" + Arrays.toString(arr) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }

    public void jump(){
        System.out.println("狗跳的很高");
    }
}
    <?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">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
    <bean id="demo" class="com.qcby.Demo"/>
<!--    <bean id="user" class="com.qcby.User"/>-->
    <!--通过get/set方法-->
    <bean id="cat" class="com.qcby.Cat">
        <!--property：完成属性注入的标签  name：要赋值的属性名称  value：要赋值的值  ref：用来做对象映射-->
        <property name="age" value="10"/>
        <prope编程客栈rty name="num" value="100"/>
        <property name="name" value="小白"/>
        <property name="height" value="10.27"/>
        <property name="demo" ref="demo"/><!-- 写这行是要先把第9行写上-->
    </bean>

    <bean id="dog" class="com.qcby.Dog">
        <property name="arr">
            <array>
                <value>11</value>
                <value>12</value>
                <value>100</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>熊大</value>
                <value>熊二</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="aaa" value="a"/>
                <entry key="bbb" value="b"/>
            </map>
        </property>
    </bean>

    <!--通过构造器-->
    <bean id="user" class="com.qcby.User">
        <constructor-arg name="height" value="56.1"></constructor-arg>
        <constructor-arg name="name" value="小红"></constructor-arg>
        <constructor-arg name="demo" ref="demo"></constructor-arg>
    </bean>
    

    <!-- 扫描com.qcby下有哪些类，获取全类名，方便创建对象-->
<!--    <context:component-scan base-package="com.qcby"/>-->
</beans>
    import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlwww.devze.comApplicationContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
        System.out.println(user);
    }

    @org.junit.Test
    public void run3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Cat cat = (Cat)context.getBean("cat");
        cat.run();
        System.out.println(cat);
    }

    @org.junit.Test
    public void run4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Dog dog = (Dog)context.getBean("dog");
        dog.jump();
        System.out.println(dog);
    }
}
    • 基于注解的方式
    package com.qcby;

import org.springframework.stereotype.Service;

@Service
public class Demo {
    public void hello(){
        System.out.println("hello world");
    }
}
    package com.qcby;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class Cat {
    //简单类型
    @Value(value="10")
    private int age;
    @Value(value="100")
    private Integer num;
    @Value(value="104.5")
    private double height;
    @Value(value="张三")
    private String name;
    @Autowired   //这个会自动映射
    private Demo demo;

    public int getAge() {
        return age;
    }

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

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public 编程客栈double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public Demo getDemo() {
        return demo;
    }

    public void setDemo(Demo demo) {
        this.demo = demo;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", num=" + num +
                ", height=" + height +
                ", name='" + name + '\'' +
                ", demo=" + demo +
                '}';
    }

    public void run(){
        System.out.println("猫跑的很快……");
    }
}
    <?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">

    <!-- IOC管理对象的方式-->
    <!-- Spring基于xml的方式去创建对象-->
<!--    <bean id="demo" class="com.qcby.Demo"/>-->
<!--    <bean id="user" class="com.qcby.User"/>-->
    <!--通过get/set方法-->
<!--    <bean id="cat" class="com.qcby.Cat">-->
<!--        <!&ndash;property：完成属性注入的标签  name：要赋值的属性名称  value：要赋值的值  ref：用来做对象映射&ndash;>-->
<!--        <property name="age" value="10"/>-->
<!--        <property name="num" value="100"/>-->
<!--        <property name="name" value="小白"/>-->
<!--        <property name="height" value="10.27"/>-->
<!--        <property name="demo" ref="demo"/><!&ndash; 写这行是要先把第9行写上&ndash;>-->
<!--    </bean>-->

<!--    <bean id="dog" class="com.qcby.Dog">-->
<!--        <property name="arr">-->
<!--            <array>-->
<!--                <value>11</value>-->
<!--                <value>12</value>-->
<!--                <value>100</value>-->
<!--            </array>-->
<!--        </property>-->
<!--        <property name="list">-->
<!--            <list>-->
<!--                <value>熊大</value>-->
<!--                <value>熊二</value>-->
<!--            </list>-->
<!--        </property>-->
<!--        <property name="map">-->
<!--            <map>-->
<!--                <entry key="aaa" value="a"/>-->
<!--                <entry key="bbb" value="b"/>-->
<!--            </map>-->
<!--        </property>-->
<!--    </bean>-->

<!--    <!&ndash;通过构造器&ndash;>-->
<!--    <bean id="user" class="com.qcby.User">-->
<!--        <constructor-arg name="height" value="56.1"></constructor-arg>-->
<!--        <constructor-arg name="name" value="小红"></constructor-arg>-->
<!--        <constructor-arg name="demo" ref="demo"></constructor-arg>-->
<!--    </bean>-->
    

    <!-- 扫描com.qcby下有哪些类，获取全类名，方便创建对象-->
    <context:component-scan base-package="com.qcby"/>
</beans>
    import com.config.SpringConfig;
import com.qcby.Cat;
import com.qcby.Demo;
import com.qcby.Dog;
import com.qcby.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    /**
     *  传统创建对象的方式
     *  人为手动创建，每次获取对象需要new对象
     */
    @org.junit.Test
    public void run(){
        Demo demo = new Demo();
        demo.hello();
    }

    /**
     * IOC
     * 启动Spring项目的时候，Spring创建的
     * 并且会将创建的对象放在一个IOC容器中，每次需要时只用从IOC里面获取
     */
    @org.junit.Test
    public void run1(){
        ApplicationContext context = new ClassPathXmlApplphpicationContext("Spring.xml");
        Demo demo = (Demo)context.getBean("demo");
        demo.hello();
    }

    @org.junit.Test
    public void run2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        User user = (User)context.getBean("user");
        user.flay();
        System.out.println(user);
    }

    @org.junit.Test
    public void run3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Cat cat = (Cat)context.getBean("cat");
        cat.run();
        System.out.println(cat);
    }

    @org.junit.Test
    public void run4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Dog dog = (Dog)context.getBean("dog");
        dog.jump();
        System.out.println(dog);
    }
}

    1.2.4 纯注解开发

    Spring框架概述和翻转权限控制方式

    package com.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(value = "com.qcby")
public class SpringConfig {

}

    Test类中按这种方式写

    @org.junit.Test
public void run3(){
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    Cat cat = (Cat)context.getBean("cat");
    cat.run();
    System.out.println(cat);
}

    总结

    以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。

    0

    上一篇:

    :下一篇

    更多 开发 相关资讯：

    精彩评论

    暂无评论...
    登录 注册
    Qedev.com
    验证码 换一张
    取 消

    关注公众号

    热门标签

    图文推荐

    Java中如何正确的停掉线程

    Java中如何正确的停掉线程
    Spring Cache 整合 Redis 实现高效缓存的方法

    Spring Cache 整合 Redis 实现高效缓存的方法
    QT Creator配置Kit的实现示例

    QT Creator配置Kit的实现示例
    从基础到高级详解Python文本分词的完全指南

    从基础到高级详解Python文本分词的完全指南
    从基础到高级详解Python数值格式化输出的完全指南

    从基础到高级详解Python数值格式化输出的完全指南
    Go语言sync锁与对象池的实现

    Go语言sync锁与对象池的实现
    Go语言ants协程池的具体使用

    Go语言ants协程池的具体使用
    Spring Boot中处理Servlet路径映射问题解决

    Spring Boot中处理Servlet路径映射问题解决

    开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

    法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

    Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9