自定义springboot starter-以cas-client为例

最新推荐文章于 2024-07-30 19:45:00 发布
最新推荐文章于 2024-07-30 19:45:00 发布
阅读量661 收藏
点赞数
分类专栏： # CAS 常用 文章标签： 自定义starter spring boot cas client
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ory001/article/details/115704941
版权
常用 同时被 2 个专栏收录
52 篇文章 1 订阅
订阅专栏
CAS
7 篇文章 0 订阅
订阅专栏

文章目录

本文以编写spring-boot-cas-client为例，自定义一个starter；
实际项目过程中，推荐使用cas-client-autoconfig-support,该jar由第三方封装，功能较为全面；若与权限认证框架集成，可以选用相应的封装jar；shiro可选用pac4j,spring-security可选用spring-security-cas

<!-- https://mvnrepository.com/artifact/net.unicon.cas/cas-client-autoconfig-support -->
<dependency>
    <groupId>net.unicon.cas</groupId>
    <artifactId>cas-client-autoconfig-support</artifactId>
    <version>2.3.0-GA</version>
</dependency>

一.目录结构

D:\IDEA\uccp-spring-boot-starter>tree /F

D:.
│  pom.xml
└─src
    └─main
        ├─java
        │  └─com
        │      └─example
        │          └─uccp
        │              └─spring
        │                  └─boot
        │                      │  UccpAutoConfigure.java
        │                      │
        │                      └─autoconfigure
        │                          ├─filters
        │                          │      UccpFilterProxy.java
        │                          │      VirtualFilterChain.java
        │                          │
        │                          └─properties
        │                                  UccpProperties.java
        │
        └─resources
            └─META-INF
                    spring-configuration-metadata.json
                    spring.factories

二、代码

1.com.example.uccp.spring.boot.autoconfigure.properties.UccpProperties
package com.example.uccp.spring.boot.autoconfigure.properties;

import org.jasig.cas.client.Protocol;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @author ：ouruyi
 * @version 1.0
 * @date ：Created in 2021/4/10 10:51
 * 功能描述：
 */
@ConfigurationProperties(prefix = "uccp")
public class UccpProperties {

    /**
     * 是否启用配置
     */
    private boolean enabled;
    /**
     * uccp-server地址
     * 示例：http://server.example.org:8800/uccp-server
     */
    private String casServerUrl;
    /**
     * uccp-service地址
     * 示例：http://service.example.org:8800/uccp-service
     */
    private String casServiceUrl;
    /**
     * cas client地址
     * 示例：http://client.example.org:8080
     */
    private String clientUrl;
    /**
     * uccp-service api接口调用code
     */
    private String appCode;
    /**
     * uccp-service api接口调用secret
     */
    private String appSecret;

    /**
     * 协议类型 {@link org.jasig.cas.client.Protocol}
     */
    private Protocol protocol;
    /**
     * 排除链接（多个用逗号分隔）
     */
    private String excludes;
    /**
     * filter拦截url
     */
    private String urlPatterns;

    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    public String getCasServerUrl() {
        return casServerUrl;
    }

    public void setCasServerUrl(String casServerUrl) {
        this.casServerUrl = casServerUrl;
    }

    public String getCasServiceUrl() {
        return casServiceUrl;
    }

    public void setCasServiceUrl(String casServiceUrl) {
        this.casServiceUrl = casServiceUrl;
    }

    public String getClientUrl() {
        return clientUrl;
    }

    public void setClientUrl(String clientUrl) {
        this.clientUrl = clientUrl;
    }

    public String getAppCode() {
        return appCode;
    }

    public void setAppCode(String appCode) {
        this.appCode = appCode;
    }

    public String getAppSecret() {
        return appSecret;
    }

    public void setAppSecret(String appSecret) {
        this.appSecret = appSecret;
    }

    public Protocol getProtocol() {
        return protocol;
    }

    public void setProtocol(Protocol protocol) {
        this.protocol = protocol;
    }

    public String getExcludes() {
        return excludes;
    }

    public void setExcludes(String excludes) {
        this.excludes = excludes;
    }

    public String getUrlPatterns() {
        return urlPatterns;
    }

    public void setUrlPatterns(String urlPatterns) {
        this.urlPatterns = urlPatterns;
    }

    @Override
    public String toString() {
        return "UccpProperties{" +
                "enabled=" + enabled +
                ", casServerUrl='" + casServerUrl + '\'' +
                ", casServiceUrl='" + casServiceUrl + '\'' +
                ", clientUrl='" + clientUrl + '\'' +
                ", appCode='" + appCode + '\'' +
                ", appSecret='" + appSecret + '\'' +
                ", protocol=" + protocol +
                ", excludes='" + excludes + '\'' +
                ", urlPatterns='" + urlPatterns + '\'' +
                '}';
    }
}
2.com.example.uccp.spring.boot.UccpAutoConfigure
package com.example.uccp.spring.boot;

import cn.hutool.core.util.StrUtil;
import com.example.uccp.spring.boot.autoconfigure.filters.UccpFilterProxy;
import com.example.uccp.spring.boot.autoconfigure.properties.UccpProperties;
import org.jasig.cas.client.util.AbstractCasFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

/**
 * @author ：ouruyi
 * @version 1.0
 * @date ：Created in 2021/4/10 10:36
 * 功能描述：自动配置类
 */
@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass(AbstractCasFilter.class)
@ConditionalOnProperty(prefix = "uccp", name = "enabled", havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(UccpProperties.class)
public class UccpAutoConfigure {

    public static final Logger logger = LoggerFactory.getLogger(UccpProperties.class);

    @Resource
    UccpProperties uccpProperties;

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new UccpFilterProxy(uccpProperties));
        filterRegistrationBean.addInitParameter("timeOut", "30");
        filterRegistrationBean.addInitParameter("excludes", uccpProperties.getExcludes());
        filterRegistrationBean.setEnabled(true);
        filterRegistrationBean.addUrlPatterns(StrUtil.split(uccpProperties.getUrlPatterns(), ","));
        filterRegistrationBean.setOrder(10);
        return filterRegistrationBean;
    }

}
3.spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.example.uccp.spring.boot.UccpAutoConfigure
4.com.example.uccp.spring.boot.autoconfigure.filters.UccpFilterProxy
package com.example.uccp.spring.boot.autoconfigure.filters;

import cn.hutool.core.util.StrUtil;
import com.example.uccp.spring.boot.autoconfigure.properties.UccpProperties;
import org.jasig.cas.client.Protocol;
import org.jasig.cas.client.authentication.AuthenticationFilter;
import org.jasig.cas.client.session.SingleSignOutFilter;
import org.jasig.cas.client.util.AssertionThreadLocalFilter;
import org.jasig.cas.client.util.HttpServletRequestWrapperFilter;
import org.jasig.cas.client.validation.Cas20ProxyReceivingTicketValidationFilter;
import org.jasig.cas.client.validation.Cas20ServiceTicketValidator;
import org.jasig.cas.client.validation.Cas30ProxyReceivingTicketValidationFilter;
import org.jasig.cas.client.validation.Cas30ServiceTicketValidator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author ：ouruyi
 * @version 1.0
 * @date ：Created in 2021/4/10 12:42
 * 功能描述：
 */
public class UccpFilterProxy implements Filter {

    public static final Logger logger = LoggerFactory.getLogger(UccpFilterProxy.class);

    private int sessionTimeOut = 30;

    private UccpProperties uccpProperties;

    private Filter[] filters;

    /**
     * 排除链接
     */
    public List<String> excludes = new ArrayList<>();

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

        String timeOut = filterConfig.getInitParameter("timeOut");

        final String excludesParam = filterConfig.getInitParameter("excludes");

        if (StrUtil.isNotBlank(excludesParam)) {
            String[] url = excludesParam.split(",");
            for (int i = 0; url != null && i < url.length; i++) {
                excludes.add(url[i]);
            }
        }

        try {
            this.sessionTimeOut = Integer.parseInt(timeOut);
        } catch (NumberFormatException e) {
            logger.debug("非法数值！{}", timeOut);
        }

        this.filters = this.obtainAllDefinedFilters();

        for (int i = 0; i < this.filters.length; ++i) {
            if (this.filters[i] != null) {
                logger.debug("filter {} is inited!", this.filters[i]);
                this.filters[i].init(filterConfig);
            }
        }
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
        HttpSession session = httpRequest.getSession(false);
        if (session != null && this.sessionTimeOut > 0) {
            session.setMaxInactiveInterval(this.sessionTimeOut * 60);
        }

        if (servletResponse instanceof HttpServletResponse) {
            ((HttpServletResponse) servletResponse).setHeader("P3P", "CP=CAO PSA OUR IDC DSP COR ADM DEVi TAIi PSD IVAi IVDi CONi HIS IND CNT");
        }

        if (!handleExcludeURL(httpRequest, httpResponse)) {
            if (this.filters != null && this.filters.length > 0) {
                VirtualFilterChain virtualFilterChain = new VirtualFilterChain(this.filters);
                virtualFilterChain.doFilter(servletRequest, servletResponse);
            }
        }
        filterChain.doFilter(servletRequest, servletResponse);

    }

    @Override
    public void destroy() {
        for (Filter filter : this.filters) {
            logger.debug("filter {} is destroyed!", filter);
            filter.destroy();
        }
    }


    private Filter[] obtainAllDefinedFilters() {
        Set<Filter> list = new LinkedHashSet();
        SingleSignOutFilter signOutFilter = new SingleSignOutFilter();
        signOutFilter.setCasServerUrlPrefix(uccpProperties.getCasServerUrl());
        signOutFilter.setIgnoreInitConfiguration(true);
        list.add(signOutFilter);

        AuthenticationFilter authenticationFilter = new AuthenticationFilter();
        StringBuilder loginUrl = new StringBuilder();
        loginUrl.append(uccpProperties.getCasServerUrl())
                .append("/login?appCode=")
                .append(uccpProperties.getAppCode());
        authenticationFilter.setCasServerLoginUrl(loginUrl.toString());
        authenticationFilter.setServerName(uccpProperties.getClientUrl());
        authenticationFilter.setIgnoreInitConfiguration(true);
        list.add(authenticationFilter);

        if (Protocol.CAS3 == uccpProperties.getProtocol()) {
            Cas30ProxyReceivingTicketValidationFilter validationFilter = new Cas30ProxyReceivingTicketValidationFilter();
            validationFilter.setUseSession(true);
            validationFilter.setServerName(uccpProperties.getClientUrl());
            validationFilter.setRedirectAfterValidation(true);
            validationFilter.setMillisBetweenCleanUps(60000);
            validationFilter.setIgnoreInitConfiguration(true);
            validationFilter.setTicketValidator(new Cas30ServiceTicketValidator(uccpProperties.getCasServerUrl()));
            list.add(validationFilter);
        } else {
            Cas20ProxyReceivingTicketValidationFilter validationFilter = new Cas20ProxyReceivingTicketValidationFilter();
            validationFilter.setUseSession(true);
            validationFilter.setServerName(uccpProperties.getClientUrl());
            validationFilter.setRedirectAfterValidation(true);
            validationFilter.setMillisBetweenCleanUps(60000);
            validationFilter.setIgnoreInitConfiguration(true);
            validationFilter.setTicketValidator(new Cas20ServiceTicketValidator(uccpProperties.getCasServerUrl()));
            list.add(validationFilter);
        }

        list.add(new AssertionThreadLocalFilter());

        list.add(new HttpServletRequestWrapperFilter());
        return list.toArray(new Filter[list.size()]);

    }

    /**
     * 直接放行url
     * @param request
     * @param response
     * @return
     */
    private boolean handleExcludeURL(HttpServletRequest request, HttpServletResponse response) {
        if (excludes == null || excludes.isEmpty()) {
            return false;
        }
        String url = request.getServletPath();
        for (String pattern : excludes) {
            Pattern p = Pattern.compile("^" + pattern);
            Matcher m = p.matcher(url);
            if (m.find()) {
                return true;
            }
        }
        return false;
    }

    public UccpFilterProxy(UccpProperties uccpProperties) {
        this.uccpProperties = uccpProperties;
    }

    public UccpFilterProxy() {

    }

    public UccpProperties getUccpProperties() {
        return uccpProperties;
    }

    public void setUccpProperties(UccpProperties uccpProperties) {
        this.uccpProperties = uccpProperties;
    }

}
5.com.example.uccp.spring.boot.autoconfigure.filters.VirtualFilterChain
package com.example.uccp.spring.boot.autoconfigure.filters;

import javax.servlet.*;
import java.io.IOException;

/**
 * @author ：ouruyi
 * @version 1.0
 * @date ：Created in 2021/4/13 17:26
 * 功能描述：自定义filterChain
 * @see org.apache.catalina.core.ApplicationFilterChain
 */
public class VirtualFilterChain implements FilterChain {

    private int i = 0;
    private Filter[] filters;

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {

        int currentIndex = ++i - 1;
        if (currentIndex < filters.length) {
            filters[currentIndex].doFilter(servletRequest, servletResponse, this);
        }

    }

    public Filter[] getFilters() {
        return filters;
    }

    public void setFilters(Filter[] filters) {
        this.filters = filters;
    }

    public VirtualFilterChain(Filter[] filters) {
        this.filters = filters;
    }

    public VirtualFilterChain() {
    }
}
6.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>uccp-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>uccp-spring-boot-starter</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <cas.version>3.5.0</cas.version>
        <spring-boot.version>2.4.4</spring-boot.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <!-- Import dependency management from Spring Boot,not include plugin
                    management as the parent import style -->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jasig.cas.client</groupId>
            <artifactId>cas-client-core</artifactId>
            <version>${cas.version}</version>
        </dependency>

        <!--hutool工具类-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-core</artifactId>
            <version>5.4.7</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
            </plugin>
        </plugins>
    </build>

</project>

说明：

spring-configuration-metadata.json 文件在项目build时自动生成(前提pom.xml中配置了spring-boot-configuration-processor),这样打包之后，在application.yaml中就可出现属性配置提示信息。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
搬山境KL攻城狮
关注
专栏目录
cas-client-autoconfig-support, Apereo Java客户端支持基于注释的配置.zip
09-18
cas-client-autoconfig-support, Apereo Java客户端支持基于注释的配置 cas-client-autoconfig-support 为CAS Java客户端提供基于注释的配置支持的库，这个项目是作为Unicon的开源支持程序的一部
CAS4.1单点登录实现（包含原理配置实现及简易demo）
weixin_53646950的博客
12-28 2847
CAS单点登录-简介 CAS 简介 CAS （ Central Authentication Service ） 是 Yale 大学发起的一个企业级的、开源的项目，旨在为 Web 应用系统提供一种可靠的单点登录解决方法（属于 Web SSO ）。 SSO 简介 单点登录（ Single Sign-On , 简称 SSO ）是目前比较流行的服务于企业业务整合的解决方案之一， SSO 使得在多个应用系统中，用户只需要 登录一次 就可以访问所有相互信任的应用系统。 CAS 的基本原理 从结构体
使用SpringBoot集成CAS、应用场景和示例代码
最新发布
a_beiyo的博客
07-30 488
配置CAS客户端，使其能够与CAS服务器进行通信。配置Spring Security，以便应用程序能够使用CAS进行身份验证。编写必要的配置和代码，确保CAS和Spring Security协同工作。通过以上配置和代码示例，你可以实现Spring Boot与CAS的集成，为你的应用程序提供单点登录功能，确保用户能够通过一次登录访问多个应用，提升用户体验和安全性。
cas-client基于CAS协议客户端搭建
梧桐树的博客
09-15 754
前面介绍了cas服务端的搭建,今天来介绍一下基于cas协议客户端的搭建,下面是服务端搭建的介绍解决了服务端的问题,客户端的搭建就简单多了。
SpringBoot+Cas整合2-1
吴永杰的博客
01-13 502
SpringBoot+Cas整合导入pom加入配置信息启动类添加注解修改配置1.重写AuthenticationRedirectStrategy 的redirect方法2.让重写的方法发挥作用,在初始化的时候就替换掉原有的方法3.如果后端接口跨域,可以加入以下配置 导入pom <dependency> <groupId>net.unicon.cas</groupId> <artifactId>cas-client-autoconfig-supp
CAS客户端对接
菲律宾铁猴子的博客
08-08 1736
CAS客户端配置
springboot-starter-gemini 一个基于gemini提供的springboot sdk
02-22
而SpringBoot-Starter-Gemini，正是在SpringBoot基础上，为开发者提供的一套针对Gemini平台的SDK，它旨在简化与Gemini的集成，加速人工智能应用的开发过程。 SpringBoot-Starter-Gemini的核心目标是提供一套完整的...
自定义 SpringBoot-Starter email-spring-boot-starter.zip
07-13
为了简化开发过程，开发者经常创建自定义的Spring Boot Starter，以便于复用和快速集成特定功能。本项目"email-spring-boot-starter"就是一个这样的例子，它提供了一个方便的邮件发送服务，能够直接与126、QQ等主流...
自定义springboot-starter项目源码【cwp-spring-boot-starter】
07-31
对于一个SpringBoot Starter项目，`pom.xml`通常会包含对`spring-boot-starter-parent`的继承，这样可以获取SpringBoot的版本管理和约定配置。同时，它也会列出其他必要的依赖，比如`spring-boot-starter`、`spring-...
Java开发案例-springboot-66-自定义starter-源代码+文档.rar
05-31
Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-...
使用了自定义springboot-starter组件的示例项目【study-springboot】
07-31
它们通常以`spring-boot-starter-<name>`的形式命名，如`spring-boot-starter-web`用于Web服务，`spring-boot-starter-data-jpa`用于数据库访问等。自定义Starter允许我们封装我们的业务逻辑或特定技术的集成，使得...
spring boot 整合 cas客户端总结
pauony的博客
02-07 552
1，项目的pom.xml文件新建maven依赖。 <dependency> <groupId>net.unicon.cas</groupId> <artifactId>cas-client-autoconfig-support</artifactId> ...
SpringBoot+CAS Client 实现单点登录
weixin_43903629的博客
06-08 567
学习
cas登录流程解析及springboot集成cas
qq_65642052的博客
08-08 4356
cas详细登录流程及springboot集成cas（前后端一体）
SpringBoot整合Cas
qq_38410795冰淇淋的博客
08-31 3192
3、自定义过滤器MyAuthenticationFilter复制AuthenticationFilter只需修改doFilter方法即可。1、启动类里注释启用cas客户端的注解。7、工具类CasServerUtil。
springboot整个cas_SpringBoot集成CAS单点登录
weixin_42514654的博客
02-04 678
SpringBoot集成CAS单点登录退出，简单几步即可搞定。1.pom.xml中引入依赖net.unicon.cascas-client-autoconfig-support1.5.0-GA2.application.properties中加入配置#cas配置cas.server-url-prefix=http://10.0.192.132:8080/cas //单点登录服务器地址cas.ser...
单点登录CAS实现
weixin_46894136的博客
06-04 8431
当用户尝试访问其他应用程序或系统时，这些应用程序或系统会向身份提供者发送身份验证请求，并使用之前获得的授权令牌进行授权。单点登录（Single Sign-On，简称SSO）是一种身份验证技术，它允许用户使用一组凭据（如用户名和密码）登录到多个应用程序或系统中，而无需在每个应用程序或系统中单独登录。当用户尝试访问其他应用程序或系统时，这些应用程序或系统会检查Cookie中的身份验证信息，并使用该信息进行身份验证和授权。使用单点登录技术，员工可以在这些应用程序之间无缝地切换，而无需在每个应用程序中单独登录。
cas实现sso单点登录（客户端）
qq_36090537的博客
01-03 1116
springboot项目整合cas-client的代码实现。
自定义springboot-starter
07-27
在父模块的pom文件中，你需要引入Spring Boot的依赖，例如spring-boot-starter-web，以及指定Spring Boot的版本。这样，你的自定义starter模块就可以基于Spring Boot进行开发和使用。\[2\] 最后，你需要创建一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

搬山境KL攻城狮

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

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

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

打赏作者

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

抵扣说明：

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

余额充值