Spring Security 实现 antMatchers 配置路径的动态获取

已于 2022-12-27 13:09:51 修改
阅读量2.1k 收藏 4
点赞数
分类专栏： spring framework spring cloud 文章标签： spring java servlet
于 2022-12-26 15:16:55 首次发布
版权所有,转载请注明出处。
本文链接：https://blog.csdn.net/echizao1839/article/details/128444750
版权

原文：Spring Security 实现 antMatchers 配置路径的动态获取 - 黑帽子技术的个人空间 - OSCHINA - 中文开源技术交流社区​​​​​​

1，引入pom

<dependency>
    <groupId>org.hepeng</groupId>
    <artifactId>hp-java-commons</artifactId>
    <version>1.1.3</version>
</dependency>

2，实现 SecurityConfigAttributeLoader (这里也可以从数据库获取)

@Configuration
@RefreshScope
public class MemorySecurityConfigAttributeLoader implements SecurityConfigAttributeLoader {

    @Value("${s-supply-chain-crm.white-list}")
    private String whiteList;

    @Value("${s-supply-chain-crm.black-list}")
    private String blackList;

    @Override
    public LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> loadConfigAttribute(HttpServletRequest request) {
        LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> requestMatcherCollectionLinkedHashMap = new LinkedHashMap<>();
        if (StringUtils.isNotBlank(whiteList)) {
            Arrays.asList(whiteList.split(",")).forEach(url -> {
                AntPathRequestMatcher antPathRequestMatcher = new AntPathRequestMatcher(url);
                SecurityAccessConfigHelper securityAccessConfigHelper = new SecurityAccessConfigHelper();
                List<ConfigAttribute> configAttributes = SecurityConfig.createList(securityAccessConfigHelper.permitAll().access());
                requestMatcherCollectionLinkedHashMap.put(antPathRequestMatcher, configAttributes);
            });
        }
        if (StringUtils.isNotBlank(blackList)) {
            Arrays.asList(blackList.split(",")).forEach(url -> {
                AntPathRequestMatcher antPathRequestMatcher = new AntPathRequestMatcher(url);
                SecurityAccessConfigHelper securityAccessConfigHelper = new SecurityAccessConfigHelper();
                List<ConfigAttribute> configAttributes = SecurityConfig.createList(securityAccessConfigHelper.denyAll().access());
                requestMatcherCollectionLinkedHashMap.put(antPathRequestMatcher, configAttributes);
            });
        }
        return requestMatcherCollectionLinkedHashMap;
    }
}

3，配置

  @Override
    public void configure(HttpSecurity http) throws Exception {     
               http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and().authorizeRequests()
                .anyRequest().authenticated()
                .withObjectPostProcessor(new CustomizeSecurityMetadataSourceObjectPostProcessor(new MemorySecurityConfigAttributeLoader()))
                .withObjectPostProcessor(new GlobalSecurityExpressionHandlerCacheObjectPostProcessor());
    }

4，扩展spring oauth2 资源服务器

package com.lemontree.crm.utils;

import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectUtils {
    public static Class<?>[] types(Object... values) {
        if (values == null) {
            return new Class[0];
        } else {
            Class<?>[] result = new Class[values.length];

            for(int i = 0; i < values.length; ++i) {
                Object value = values[i];
                result[i] = value == null ? NULL.class : value.getClass();
            }

            return result;
        }
    }
    private static class NULL {
        private NULL() {
        }
    }
    public static Method similarMethod(Class t, String name, Class<?>[] types) throws NoSuchMethodException {
        Method[] var4 = t.getMethods();
        int var5 = var4.length;

        int var6;
        Method method;
        for(var6 = 0; var6 < var5; ++var6) {
            method = var4[var6];
            if (ReflectUtils.isSimilarSignature(method, name, types)) {
                return method;
            }
        }

        do {
            var4 = t.getDeclaredMethods();
            var5 = var4.length;

            for(var6 = 0; var6 < var5; ++var6) {
                method = var4[var6];
                if (isSimilarSignature(method, name, types)) {
                    return method;
                }
            }

            t = t.getSuperclass();
        } while(t != null);

        throw new NoSuchMethodException("No similar method " + name + " with params " + Arrays.toString(types) + " could be found on type .");
//        throw new NoSuchMethodException("No similar method " + name + " with params " + Arrays.toString(types) + " could be found on type " + this.type() + ".");
    }
    private static boolean isSimilarSignature(Method possiblyMatchingMethod, String desiredMethodName, Class<?>[] desiredParamTypes) {
        return possiblyMatchingMethod.getName().equals(desiredMethodName) && match(possiblyMatchingMethod.getParameterTypes(), desiredParamTypes);
    }
    private static boolean match(Class<?>[] declaredTypes, Class<?>[] actualTypes) {
        if (declaredTypes.length == actualTypes.length) {
            for(int i = 0; i < actualTypes.length; ++i) {
                if (actualTypes[i] != NULL.class && !wrapper(declaredTypes[i]).isAssignableFrom(wrapper(actualTypes[i]))) {
                    return false;
                }
            }

            return true;
        } else {
            return false;
        }
    }
    public static <T> Class<T> wrapper(Class<T> type) {
        if (type == null) {
            return null;
        } else {
            if (type.isPrimitive()) {
                if (Boolean.TYPE == type) {
                    return (Class<T>) Boolean.class;
                }

                if (Integer.TYPE == type) {
                    return (Class<T>) Integer.class;
                }

                if (Long.TYPE == type) {
                    return (Class<T>) Long.class;
                }

                if (Short.TYPE == type) {
                    return (Class<T>) Short.class;
                }

                if (Byte.TYPE == type) {
                    return (Class<T>) Byte.class;
                }

                if (Double.TYPE == type) {
                    return (Class<T>) Double.class;
                }

                if (Float.TYPE == type) {
                    return (Class<T>) Float.class;
                }

                if (Character.TYPE == type) {
                    return (Class<T>) Character.class;
                }

                if (Void.TYPE == type) {
                    return (Class<T>) Void.class;
                }
            }

            return type;
        }
    }
    public static Method exactMethod(Class t,String name, Class<?>[] types) throws NoSuchMethodException {
        try {
            return t.getMethod(name, types);
        } catch (NoSuchMethodException var7) {
            while(true) {
                try {
                    return t.getDeclaredMethod(name, types);
                } catch (NoSuchMethodException var6) {
                    t = t.getSuperclass();
                    if (t == null) {
                        throw new NoSuchMethodException();
                    }
                }
            }
        }
    }
}

package com.lemontree.crm.config.refresh;

import cn.hutool.core.util.ReflectUtil;
import com.lemontree.crm.utils.ReflectUtils;
import org.joor.Reflect;
import org.springframework.expression.ExpressionParser;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityMetadataSource;
import org.springframework.security.access.expression.SecurityExpressionHandler;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.expression.ExpressionBasedFilterInvocationSecurityMetadataSource;
import org.springframework.security.web.access.intercept.DefaultFilterInvocationSecurityMetadataSource;
import org.springframework.security.web.util.matcher.RequestMatcher;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.*;

/**
 * @author lwc
 */
public class CustomizeConfigSourceFilterInvocationSecurityMetadataSource extends DefaultFilterInvocationSecurityMetadataSource {


    private SecurityMetadataSource delegate;
    private SecurityConfigAttributeLoader metadataSourceLoader;
    private ExpressionParser expressionParser;
    private SecurityExpressionHandler<FilterInvocation> expressionHandler;

    public CustomizeConfigSourceFilterInvocationSecurityMetadataSource(
            SecurityMetadataSource delegate,
            SecurityConfigAttributeLoader metadataSourceLoader, SecurityExpressionHandler<FilterInvocation> expressionHandler) {
        super(new LinkedHashMap<>());
        this.delegate = delegate;
        this.metadataSourceLoader = metadataSourceLoader;
        this.expressionHandler = expressionHandler;

        copyDelegateRequestMap();
    }

    private void copyDelegateRequestMap() {
        ReflectUtil.setFieldValue(this,"requestMap",getDelegateRequestMap());
    }

    private LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> getDelegateRequestMap() {
        return (LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>>) ReflectUtil.getFieldValue(this.delegate,"requestMap");
    }


    @Override
    public Collection<ConfigAttribute> getAttributes(Object object) {
        final HttpServletRequest request = ((FilterInvocation) object).getRequest();
        Collection<ConfigAttribute> configAttributes = new ArrayList<>();
        LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> requestMap =
                this.metadataSourceLoader.loadConfigAttribute(request);

        if (requestMap == null || requestMap.size() == 0) {
            configAttributes.addAll(this.delegate.getAttributes(object));
            return configAttributes;
        }

        if (Objects.isNull(this.expressionParser)) {
            this.expressionParser = expressionHandler.getExpressionParser();
        }


        Class<ExpressionBasedFilterInvocationSecurityMetadataSource> expressionBasedFilterInvocationSecurityMetadataSourceClass = ExpressionBasedFilterInvocationSecurityMetadataSource.class;//ExpressionBasedFilterInvocationSecurityMetadataSource
        LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> webExpressionRequestMap = null;
        Class<?>[] types = ReflectUtils.types(requestMap, this.expressionParser);
        try {
            Method processMap = ReflectUtils.exactMethod(expressionBasedFilterInvocationSecurityMetadataSourceClass, "processMap", types);
            processMap.setAccessible(true);
            webExpressionRequestMap = (LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>>) processMap.invoke(expressionBasedFilterInvocationSecurityMetadataSourceClass, requestMap, this.expressionParser);

        } catch (Exception e) {
            try {
                Method processMap = ReflectUtils.similarMethod(expressionBasedFilterInvocationSecurityMetadataSourceClass, "processMap", types);
                processMap.setAccessible(true);
                webExpressionRequestMap = (LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>>) processMap.invoke(expressionBasedFilterInvocationSecurityMetadataSourceClass, requestMap, this.expressionParser);
            } catch (Exception noSuchMethodException) {
                noSuchMethodException.printStackTrace();
            }
        }

        for (Map.Entry<RequestMatcher, Collection<ConfigAttribute>> entry : webExpressionRequestMap.entrySet()) {
            if (entry.getKey().matches(request)) {
                configAttributes.addAll(entry.getValue());
                break;
            }
        }

        configAttributes.addAll(this.delegate.getAttributes(object));
        return configAttributes;
    }
}

package com.lemontree.crm.config.refresh;

import org.springframework.security.access.expression.SecurityExpressionHandler;
import org.springframework.security.config.annotation.ObjectPostProcessor;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;

/**
 * @author lwc
 */
public class CustomizeSecurityMetadataSourceObjectPostProcessor implements ObjectPostProcessor<FilterSecurityInterceptor> {

    private SecurityConfigAttributeLoader securityConfigAttributeLoader;

    private SecurityExpressionHandler<FilterInvocation> expressionHandler;

    public CustomizeSecurityMetadataSourceObjectPostProcessor(SecurityConfigAttributeLoader securityConfigAttributeLoader, SecurityExpressionHandler<FilterInvocation> expressionHandler) {
        this.securityConfigAttributeLoader = securityConfigAttributeLoader;
        this.expressionHandler = expressionHandler;
    }

    @Override
    public <O extends FilterSecurityInterceptor> O postProcess(O object) {
        FilterSecurityInterceptor interceptor = object;

        CustomizeConfigSourceFilterInvocationSecurityMetadataSource metadataSource =
                new CustomizeConfigSourceFilterInvocationSecurityMetadataSource(
                        interceptor.obtainSecurityMetadataSource(), securityConfigAttributeLoader, expressionHandler);
        interceptor.setSecurityMetadataSource(metadataSource);
        return (O) interceptor;
    }
}

package com.lemontree.crm.config.refresh;

import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

/**
 * @author lwc
 */
public class SecurityAccessConfigHelper {

    public static final String PERMIT_ALL = "permitAll";
    public static final String DENY_ALL = "denyAll";
    public static final String ANONYMOUS = "anonymous";
    public static final String AUTHENTICATED = "authenticated";
    public static final String FULLY_AUTHENTICATED = "fullyAuthenticated";
    public static final String REMEMBER_ME = "rememberMe";

    private StringBuilder access = new StringBuilder();

    public SecurityAccessConfigHelper permitAll() {
        and();
        this.access.append(PERMIT_ALL);
        return this;
    }

    public SecurityAccessConfigHelper denyAll() {
        and();
        this.access.append(DENY_ALL);
        return this;
    }

    public SecurityAccessConfigHelper anonymous() {
        and();
        this.access.append(ANONYMOUS);
        return this;
    }

    public SecurityAccessConfigHelper authenticated() {
        and();
        this.access.append(AUTHENTICATED);
        return this;
    }

    public SecurityAccessConfigHelper fullyAuthenticated() {
        and();
        this.access.append(FULLY_AUTHENTICATED);
        return this;
    }

    public SecurityAccessConfigHelper rememberMe() {
        and();
        this.access.append(REMEMBER_ME);
        return this;
    }

    public SecurityAccessConfigHelper hasAnyRole(String... authorities) {
        String anyAuthorities = StringUtils.arrayToDelimitedString(authorities,
                "','ROLE_");
        and();
        this.access.append("hasAnyRole('ROLE_" + anyAuthorities + "')");
        return this;
    }

    public SecurityAccessConfigHelper hasRole(String role) {
        Assert.notNull(role, "role cannot be null");
        if (role.startsWith("ROLE_")) {
            throw new IllegalArgumentException(
                    "role should not start with 'ROLE_' since it is automatically inserted. Got '"
                            + role + "'");
        }

        and();
        this.access.append("hasRole('ROLE_" + role + "')");
        return this;
    }

    public SecurityAccessConfigHelper hasAnyAuthority(String... authorities) {
        String anyAuthorities = StringUtils.arrayToDelimitedString(authorities, "','");
        and();
        this.access.append("hasAnyAuthority('" + anyAuthorities + "')");
        return this;
    }

    public SecurityAccessConfigHelper hasAuthority(String authority) {
        and();
        this.access.append("hasAuthority('" + authority + "')");
        return this;
    }

    public SecurityAccessConfigHelper hasIpAddress(String ipAddressExpression) {
        and();
        this.access.append("hasIpAddress('" + ipAddressExpression + "')");
        return this;
    }

    public String access() {
        return this.access.toString();
    }


    private SecurityAccessConfigHelper and() {
        if (this.access.length() != 0) {
            this.access.append(" and ");
        }
        return this;
    }
}

package com.lemontree.crm.config.refresh;

import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.web.util.matcher.RequestMatcher;

import javax.servlet.http.HttpServletRequest;
import java.util.Collection;
import java.util.LinkedHashMap;

/**
 * @author lwc
 */
public interface SecurityConfigAttributeLoader {

    LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> loadConfigAttribute(HttpServletRequest request);
}

package com.lemontree.crm.config.oauth;

import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
import com.lemontree.crm.config.refresh.SecurityAccessConfigHelper;
import com.lemontree.crm.config.refresh.SecurityConfigAttributeLoader;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import org.springframework.security.web.util.matcher.RequestMatcher;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * @author liwenchao
 */
@Configuration
@RefreshScope
@Slf4j
public class MemorySecurityConfigAttributeLoader implements SecurityConfigAttributeLoader {

    @Override
    public LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> loadConfigAttribute(HttpServletRequest request) {
        LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> requestMatcherCollectionLinkedHashMap = new LinkedHashMap<>();
        //获取当前环境
        String activeProfile = SpringUtil.getActiveProfile();
        String application = request.getHeader("application");
        log.info("crm当前运行环境：{}",activeProfile);
        log.info("crm请求头application：{}",application);
        if (!"app".equalsIgnoreCase(application) || "local".equalsIgnoreCase(activeProfile)) {
            AntPathRequestMatcher antPathRequestMatcher = new AntPathRequestMatcher("/**");
            SecurityAccessConfigHelper securityAccessConfigHelper = new SecurityAccessConfigHelper();
            List<ConfigAttribute> configAttributes = SecurityConfig.createList(securityAccessConfigHelper.permitAll().access());
            requestMatcherCollectionLinkedHashMap.put(antPathRequestMatcher,configAttributes);
            return requestMatcherCollectionLinkedHashMap;
        }
        JSONObject whiteAndBlackList = UtilsController.getWhiteAndBlackList();
        String white = whiteAndBlackList.getString("white");
        String black = whiteAndBlackList.getString("black");
        log.info("crm黑白名单列表：{}",whiteAndBlackList);
        if (StringUtils.isNotBlank(white)) {
            Arrays.asList(white.split(",")).forEach(url -> {
                AntPathRequestMatcher antPathRequestMatcher = new AntPathRequestMatcher(url);
                SecurityAccessConfigHelper securityAccessConfigHelper = new SecurityAccessConfigHelper();
                List<ConfigAttribute> configAttributes = SecurityConfig.createList(securityAccessConfigHelper.permitAll().access());
                requestMatcherCollectionLinkedHashMap.put(antPathRequestMatcher, configAttributes);
            });
        }
        if (StringUtils.isNotBlank(black)) {
            Arrays.asList(black.split(",")).forEach(url -> {
                AntPathRequestMatcher antPathRequestMatcher = new AntPathRequestMatcher(url);
                SecurityAccessConfigHelper securityAccessConfigHelper = new SecurityAccessConfigHelper();
                List<ConfigAttribute> configAttributes = SecurityConfig.createList(securityAccessConfigHelper.denyAll().access());
                requestMatcherCollectionLinkedHashMap.put(antPathRequestMatcher, configAttributes);
            });
        }
        return requestMatcherCollectionLinkedHashMap;
    }
}

package com.lemontree.crm.config.oauth;

import com.lemontree.crm.config.refresh.CustomizeSecurityMetadataSourceObjectPostProcessor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.expression.SecurityExpressionHandler;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.jwt.crypto.sign.MacSigner;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.authentication.OAuth2AuthenticationManager;
import org.springframework.security.oauth2.provider.expression.OAuth2WebSecurityExpressionHandler;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.authentication.preauth.AbstractPreAuthenticatedProcessingFilter;

/**
 * @Description
 * @Author lwc
 * @Data 2022/8/29 22:26
 */
@Configuration
@EnableResourceServer //开启资源服务器功能
@EnableWebSecurity(debug = true)  //开启web访问安全
@RefreshScope
@Slf4j
public class ResourceServerConfiger extends ResourceServerConfigurerAdapter {

    @Value("${oauth2-resource.sign-key}")
    private String SIGN_KEY; //jwt签名密钥
    //    private String sign_key = "imugua20220829"; //jwt签名密钥 ee7dcc6cad12f7d7ef9642e680fdbc4d
    @Value("${oauth2-resource.release}")
    private String release; //资源服务器标识

    private SecurityExpressionHandler<FilterInvocation> expressionHandler = new OAuth2WebSecurityExpressionHandler();

    /**
     * @Description 该⽅法⽤于定义资源服务器向远程认证服务器发起请求，进⾏token校验
     * 等事宜
     */
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        /*// 设置当前资源服务的资源id
        resources.resourceId("release");
        // 定义token服务对象（token校验就应该靠token服务对象）
        RemoteTokenServices remoteTokenServices = new RemoteTokenServices();
        // 校验端点/接⼝设置
        remoteTokenServices.setCheckTokenEndpointUrl("http://localhost:9999/oauth/check_token");
        // 携带客户端id和客户端安全码
        remoteTokenServices.setClientId("clientmugua");
        remoteTokenServices.setClientSecret("zbcxyz");

        resources.tokenServices(remoteTokenServices);*/

        //使用jwt令牌
        resources.resourceId(release).tokenStore(tokenStore()).stateless(true);//无状态设置
    }

    /**
     * @Description 场景：⼀个服务中可能有很多资源（API接⼝）
     * * 某⼀些API接⼝，需要先认证，才能访问
     * * 某⼀些API接⼝，压根就不需要认证，本来就是对外开放的接⼝
     * * 我们就需要对不同特点的接⼝区分对待（在当前configure⽅法中
     * 完成），设置是否需要经过认证
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {


        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and().authorizeRequests()
                .expressionHandler(expressionHandler)
                .anyRequest().authenticated()
                .withObjectPostProcessor(new CustomizeSecurityMetadataSourceObjectPostProcessor(new MemorySecurityConfigAttributeLoader(), expressionHandler));
    }

    /**
     * @Description 该⽅法⽤于创建tokenStore对象（令牌存储对象）
     * token以什么形式存储
     */
    public TokenStore tokenStore() {
        //return new InMemoryTokenStore();
        // 使⽤jwt令牌
        return new JwtTokenStore(jwtAccessTokenConverter());
    }


    /**
     * @Description * 返回jwt令牌转换器（帮助我们⽣成jwt令牌的）
     * 在这⾥，我们可以把签名密钥传递进去给转换器对象
     */
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
        jwtAccessTokenConverter.setSigningKey(SIGN_KEY); // 签名密钥
        jwtAccessTokenConverter.setVerifier(new MacSigner(SIGN_KEY)); // 验证时使⽤的密钥，
        // 和签名密钥保持⼀致3.3.5 从数据库加载Oauth2客户端信息
        // 创建数据表并初始化数据（表名及字段保持固定）
        return jwtAccessTokenConverter;
    }
}

浮生夢
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博客
互联网行业术语
06-22 5万+
互联网行业一般指的是互联网企业,是指以计算机网络技术为基础，利用网络平台提供服务并因此获得收入的企业。其业务范围通常覆盖全国甚至全球,注册用户通常达到千万级以上,用户活跃度也非常高,经常在同一时间点出现请求并行的情况。代表企业有阿里巴巴、腾讯、百度、东、宇节跳动,美团饿了么等。传统行业通常是指互联网向传统行业渗透,实质是传统行业需要互联网。互联网是技术平台、底层架构，它源于安全需求,却在经济领域大放异彩。传统经济正向网络经济转轨,这-有机联系的经济使各行各业均需连接, 因此以互联网为代表的联接型
博客
浏览器指纹的介绍及应用
12-06 1159
在网站上浏览某个商品，了解了相关的商品信息，但并没有下单购买，甚至没有进行登录操作。过两天用同台电脑访问其他网站的时候却发现很多同类商品的广告。在某博客中你有多个小号（水军），这些小号的存在就是为了刷某个帖子的热度或者进行舆论引导，又或者纯粹进行流量交易，即便你在切换账号的时候清空了cookie、本地缓存，重开路由器甚至使用vpn来进行操作，你觉得自己足够小心，并尽可能提高水军的真实性，但是管理人员可能还是知道这是同一个人在操作，从而被打击。
博客
数据仓库入门简介
11-14 1279
（英语：Data Warehouse，简称数仓、DW）是一个为数据分析而设计的企业级数据管理系统。它旨在支持企业决策过程中的数据分析和业务智能。数据仓库的基本原理是将不同来源的数据整合到一个中心存储库中，以提供一致的数据视图和易于理解的分析结果。通过提供这些服务，数据仓库可以帮助企业更好地理解业务、预测趋势、制定战略，并提升企业的决策水平和竞争力。数据仓库可以通过多种方式进行建模，其中最常用的是。
博客
ChatGpt 反向代理
10-14 1621
看了看网上的文章，实现接口国内访问的方法有很多。1，自己买国外服务器这种成本比较高，因为单纯的就是用个接口，专门买个服务器还是比较奢侈的。2，自己挂代理这种的使用的代理干净与否都不知道，并且有封号的风险。3，用中转key这种的需要买别人的key，背后都是一些普通5美元key组合成，这种一分钟只能请求三次，使用多账轮询，来达到生产可用的效果。4，使用别人的中转链接。
博客
Claude2 Api接入方案（现在官方提供api了）
08-14 2928
接入钉钉机器人支持群聊和私聊网上看了很多方案，因为Claude的api申请难度非常大，大部分都是说使用Slack，但是Slack只能免费使用一个月。作为一个完美主义怎么可能允许这样的事情发生。何如处理，抓网页。只能美，英，魔法这些都是入门小菜，这里不再赘述。自行解决。
博客
ChatGpt提示词大全
08-12 1万+
行为提示词Linux终端我希望你能充当一个linux终端。我将输入命令，你会回复终端应该显示什么。我想让你只回复在一个唯一的代码块内的终端输出，而没有别的。不要写一些解释。不要键入命令，除非我指示你这样做。当我需要用英语告诉你一些东西时，我会把文本放在大括号内{就像这样}。我的第一个命令是pwd英语翻译和即兴创作我希望你能担任英语翻译，拼写更正者和改进者。我将用任何语言与你交谈，你将发现该语言，翻译它，并以我的文本的修正和改进版本的英语回答。我想让你把我简化的A0级单词和句子换成更漂亮、更优雅的高级英语单词
博客
版本号规范 语义化版本 Semver Version 2.0.0
07-31 324
主版本号：当你做了不兼容的 API 修改，次版本号：当你做了向下兼容的功能性新增，修订号：当你做了向下兼容的问题修正。先行版本号及版本编译信息可以加到“主版本号.次版本号.修订号”的后面，作为延伸。在软件管理的领域里存在着被称作“依赖地狱”的死亡之谷，系统规模越大，加入的包越多，你就越有可能在未来的某一天发现自己已深陷绝望之中。在依赖高的系统中发布新版本包可能很快会成为噩梦。如果依赖关系过高，可能面临版本控制被锁死的风险（必须对每一个依赖包改版才能完成某次升级）。
博客
百度墨斗鱼文库创作中心源码分析
07-12 1156
公司解散，待业中，耗时一天研究了一下百度墨斗鱼文库创作中心源码。实现了后台自动完成任务并通知。下面主要分析一下实现思路和难点。
博客
Mysql常见的集群方案
07-10 7620
1、是官方提供的主从同步方案，用于将一个 MySQL 的实例同步到另一个实例中，在主从复制中，从库利用主库上的 binlog 进行重播，实现主从同步，默认是异步同步，针对其在不同场景下的一些缺陷，衍生出了半同步复制，强同步复制等数据高可用的方案；2、组复制又称为 MGR,引入复制组主要是为了解决传统异步复制和半同步复制可能产生数据不一致的问题, MGR 由若干个节点共同组成一个复制组，一个事务的提交，必须经过组内大多数节点 (N / 2 + 1) 决议并通过，才能得以提交;3、
博客
Springcloud之Feign、Hystrix、Ribbon如何设置超时时间
06-12 3728
我们在微服务调用服务的时候，会使用hystrix、feign和ribbon，比如有一个实例发生了故障而该情况还没有被服务治理机制及时的发现和摘除，这时候客户端访问该节点的时候自然会失败。所以，为了构建更为健壮的应用系统，我们希望当请求失败的时候能够有一定策略的重试机制，而不是直接返回失败。这里还会设计一些其他的配置参数，降级和熔断的概念不再赘述。先看这几个组件的关系hystrix在最外层，然后再到Ribbon，最后里面的是http请求。所以说。
博客
Java内存模型与线程规范详解（JMM）
06-05 294
顺序一致性内存模型是一个理论参考模型，JMM 和处理器内存模型在设计时通常会把顺序一致性内存模型作为参照。JMM 和处理器内存模型在设计时会对顺序一致性模型做一些放松，因为如果完全按照顺序一致性模型来实现处理器和 JMM，那么很多的处理器和编译器优化都要被禁止，这对执行性能将会有很大的影响。放松程序中写 - 读操作的顺序，由此产生了 total store ordering 内存模型（简称为 TSO）。
博客
一文搞懂位运算
06-05 590
接下来我们主要介绍十进制数用二进制表示的不同方法，所以为了简洁，我们用一个字节，也就是8个bit来表示二进制数。十进制原码20000 0010-21000 0010原码其实是最容易理解的，只不过需要利用二进制中的第一位来表示符号位，0表示正数，1表示负数，所以可以看到，一个数字用二进制原码表示的话，取值范围是-111 1111 ~ +111 1111，换成十进制就是-127 ~ 127。
博客
MySql MVCC 详解
05-27 5113
MVCC 是多版本并发控制（Multiversion Concurrency Control）的缩写。它是一种数据库事务管理技术，用于解决并发访问数据库的问题。MVCC 通过创建多个版本的同一数据，每个版本与一个事务关联，来实现并发控制。数据库在执行更新操作时，会保留之前版本的数据，以便其他正在执行事务的用户可以访问这些数据。每个事务都能看到一个稳定的数据快照，并且仅接触到他们自己的版本，这意味着每个事务可以独立地读取和写入数据，而不会干扰其它事务。
博客
SpringBoot启动过程源码解析
05-19 1094
否则，应用类型为WebApplicationType.SERVLET。
博客
SpringBoot自动配置底层源码解析
05-19 758
SpringBoot中众多的条件注解，都是基于Spring中的@Conditional来实现的，所以我们先来用一下@Conditional注解。先来看下@Conditional注解的定义/***/Class
博客
SpringMVC中的转发和重定向参数传递
05-18 795
model不是同一个，是不共享的，这也能体现出来model和request的区别了，每个Controller中的方法都会对应的一个Model。把要传递的参数存入outputFlashMap，在b请求里通过inputFlashMap就可以拿到了，底层是基于session来实现的。以上代码访问/a后，就会重定向到/b，但是由于是两个单独的请求（这两个请求都是由浏览器发出的，所以浏览器上的地址会变成/b）。转发就比较简单了，因为一直时同一个请求，所以数据本身就是共享的。
博客
Java 并发队列详解
05-16 1266
对head的更新也是同样的道理，虽然，这样设计会多出在循环中定位队尾节点，但总体来说读的操作效率要远远高于写的性能，因此，多出来的在循环中定位尾节点的操作的性能损耗相对而言是很小的。ConcurrentLinkedQueue通过无锁来做到了更高的并发量，是个高性能的队列，但是使用场景相对不如阻塞队列常见，毕竟取数据也要不停的去循环，不如阻塞的逻辑好设计，但是在并发量特别大的情况下，是个不错的选择，性能上好很多，而且这个队列的设计也是特别费力，尤其的使用的改良算法和对哨兵的处理。也就是说，它是有限的。
博客
Hystrix参数详解
05-12 783
若rolling window被设为10000毫秒，则rolling window会被分成n个buckets，每个bucket包含success，failure，timeout，rejection的次数的统计信息。如果设为20，那么当一个rolling window的时间内（比如说1个rolling window是10秒）收到19个请求，即使19个请求都失败，也不会触发circuit break。错误比率阀值，如果错误率>=该值，circuit会被打开，并短路所有请求触发fallback。
博客
7种常见的生产级负载均衡算法
05-10 599
准备测试数据。
博客
常用的数据中心部署架构
05-09 1371
那么我们上面考虑的应用是一个非常简单的只读应用，所以各个地方的应用是可以同时对外提供服务的，那么如果我们的应用涉及到数据存储，这个时候各个地方的应用就不能同时对外提供写入数据的服务了，因为很有可能会出现数据冲突，那么我们暂且规定只有公司内部机房里的服务器（后文我们叫主机房）可以提供写数据服务，而同城的另外一个机房以及异地的另外一个机房只能从主机房同步数据，这样这两个地方的机房的功能就叫灾备，因为数据会同步，所以就算主机房停电了，另外两个机房还是可以临时来对外提供服务的。说起数据中心，相信大家并不陌生。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值