贝壳里的沙
贝壳里的沙

29、oauth2.0 资源服务器与授权服务器分离配置

废话刷说，这个问题已经困扰我多时，我已经经过n次尝试，n-1都是失败的，最后只有一次成功，失败是成功他妈，是血的教训，佛说千万次错过就是为了那一次邂逅。

先把我遇到的问题罗列出来：

（1）资源服务器和认证服务器分离后，配置resource.id无效；

（2）存储的secret和用户密码都必须BCEncrypt加密；

（3）认证服务器同时也是资源服务器的时候，四种授权模式不能共生（我出现的是添加上资源服务器，授权码模式无效，implicit简单模式，password模式和client credentials模式有效；认证服务器不做为资源服务器的时候四种授权模式都可以生效）。

（4）Eureka注册服务，如果配置使用了Security，并配置HttpBasic登录模式后，可能与资源服务器的授权模式会冲突（最终注册服务器使用无需用户名和密码模式）。

 

父工程POM文件：

<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">

 

  <modelVersion>4.0.0modelVersion>

  <groupId>com.donwaitgroupId>

  <artifactId>DYSartifactId>

  <version>0.0.1-SNAPSHOTversion>

  <packaging>pompackaging>

  <name>道鹰4.0name>

  <description>道鹰4.0后台集群服务description>

 

 

  <parent>

      <groupId>org.springframework.bootgroupId>

      <artifactId>spring-boot-starter-parentartifactId>

      <version>2.0.4.RELEASEversion>

      <relativePath/>

  parent>

 

 

  <properties>

      <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>

      <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>

      <java.version>1.8java.version>

      <spring-cloud.version>Finchley.RELEASEspring-cloud.version>

     

      <lombok.version>1.16.20lombok.version>

      <docker.registry>localhost:5000docker.registry>

  properties>

 

 

  <dependencyManagement>

      <dependencies>

          <dependency>

              <groupId>org.springframework.cloudgroupId>

              <artifactId>spring-cloud-dependenciesartifactId>

              <version>${spring-cloud.version}version>

              <type>pomtype>

              <scope>importscope>

          dependency>

          <dependency>

              <groupId>org.springframeworkgroupId>

              <artifactId>spring-jdbcartifactId>

              <version>${spring.version}version>

          dependency>

      dependencies>

  dependencyManagement>

 

 

  <repositories>

      <repository>

          <id>spring-snapshotsid>

          <name>Spring Snapshotsname>

          <url>https://repo.spring.io/snapshoturl>

          <snapshots>

              <enabled>trueenabled>

          snapshots>

      repository>

      <repository>

          <id>spring-milestonesid>

          <name>Spring Milestonesname>

          <url>https://repo.spring.io/milestoneurl>

          <snapshots>

              <enabled>falseenabled>

          snapshots>

      repository>

  repositories>

 

 

  <dependencies>

     

     <dependency>

          <groupId>org.springframework.bootgroupId>

          <artifactId>spring-boot-starter-testartifactId>

          <scope>testscope>

     dependency>

     

     <dependency>

          <groupId>org.springframework.bootgroupId>

          <artifactId>spring-boot-starter-actuatorartifactId>

     dependency>

     

    <dependency>

          <groupId>org.springframework.bootgroupId>

          <artifactId>spring-boot-devtoolsartifactId>

          <optional>trueoptional>

     dependency>

     

     <dependency>

          <groupId>org.projectlombokgroupId>

          <artifactId>lombokartifactId>

     dependency>

  dependencies>

 

 

  <build>

      <plugins>

           

          <plugin>

              <groupId>org.springframework.bootgroupId>

              <artifactId>spring-boot-maven-pluginartifactId>

          plugin>

         

         

          <plugin>

                <groupId>com.spotifygroupId>

                <artifactId>docker-maven-pluginartifactId>

                <version>0.4.13version>

                <configuration>

                   

                   

                     <imageName>${project.name}:${project.version}imageName>

                     <dockerDirectory>${project.basedir}/src/main/dockerdockerDirectory>

                     <skipDockerBuild>falseskipDockerBuild>

                   

                   

                   <resources>

                        <resource>

                             <targetPath>/ROOTtargetPath>

                             <directory>${project.build.directory}directory>

                             <include>${project.build.finalName}.jarinclude>

                        resource>

                   resources>

                configuration>

            plugin>

      plugins>

  build>

 

 

  <modules>

     

     <module>dys_commonmodule>

     

     <module>dys_zipkin_servermodule>

     

     <module>dys_config_centermodule>

     

     <module>dys_register_servermodule>

     

     <module>dys_config_servermodule>

     

     <module>dys_gateway_servermodule>

     

     <module>dys_auth_centermodule>

     <module>dys_car_servermodule>

  modules>

 

project>

 

一、认证服务器

 

（1）POM配置文件配置

 

  4.0.0

  dys_auth_center

  授权中心

  提供用户认证以及平台服务器之间的token检查认证

  

  

    com.donwait

    DYS

    0.0.1-SNAPSHOT

  

  

  

     

     

          com.donwait

          dys_common

          0.0.1-SNAPSHOT

     

     

     

         org.springframework.cloud

          spring-cloud-starter-config

     

     

     

          org.springframework.cloud

          spring-cloud-starter-netflix-eureka-client

     

     

     

          org.springframework.cloud

          spring-cloud-starter-oauth2

     

     

     

          org.springframework.cloud

          spring-cloud-starter-security

     

     

     

          org.springframework.boot

          spring-boot-starter-data-redis

     

     

     

          mysql

          mysql-connector-java

     

     

     

          org.mybatis.spring.boot

          mybatis-spring-boot-starter

          1.3.0

     

    

     

          com.alibaba

          druid-spring-boot-starter

          1.1.9

     

     

       com.alibaba

       druid

       1.1.10

     

     

     

          io.springfox

          springfox-swagger2

          2.2.2

     

     

          io.springfox

          springfox-swagger-ui

          2.2.2

     

  

  

 

（2）认证服务器配置

package com.donwait.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Primary;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.security.authentication.AuthenticationManager;

import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;

import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;

import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;

import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;

import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;

import org.springframework.security.oauth2.provider.ClientDetailsService;

import org.springframework.security.oauth2.provider.client.JdbcClientDetailsService;

import org.springframework.security.oauth2.provider.token.DefaultTokenServices;



import com.donwait.redis.MyRedisTokenStore;

import com.donwait.service.impl.UserDetailsServiceImpl;



@Configuration

@EnableAuthorizationServer

public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {



    @Autowired

    private AuthenticationManager authenticationManager;



    @Autowired

    private DataSource dataSource;

    @Autowired

    private UserDetailsServiceImpl userDetailsService;



    @Autowired

    private RedisConnectionFactory redisConnectionFactory;



    @Bean

    @Primary

    MyRedisTokenStore redisTokenStore(){

        return new MyRedisTokenStore(redisConnectionFactory);

    }



    @Override

    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {

        clients.withClientDetails(clientDetails());

    }

    @Bean

    public ClientDetailsService clientDetails() {

        return new JdbcClientDetailsService(dataSource);

    }

    @Override

    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {

        endpoints.tokenStore(redisTokenStore())

                .userDetailsService(userDetailsService)

                .authenticationManager(authenticationManager);

        endpoints.tokenServices(defaultTokenServices());

    }



    @Primary

    @Bean

    public DefaultTokenServices defaultTokenServices(){

        DefaultTokenServices tokenServices = new DefaultTokenServices();

        tokenServices.setTokenStore(redisTokenStore());

        tokenServices.setSupportRefreshToken(true);

        tokenServices.setClientDetailsService(clientDetails());

        tokenServices.setAccessTokenValiditySeconds(60*60*12);             // token有效期自定义设置，默认12小时

        tokenServices.setRefreshTokenValiditySeconds(60 * 60 * 24 * 7);    //默认30天，这里修改

        return tokenServices;

    }



    @Override

    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {

        security.tokenKeyAccess("permitAll()");

        security .checkTokenAccess("isAuthenticated()");

        security.allowFormAuthenticationForClients();

    }

}

（3）Security资源保护配置

package com.donwait.config;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;

import org.springframework.security.config.annotation.web.builders.WebSecurity;

import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import org.springframework.security.crypto.password.PasswordEncoder;



import com.donwait.service.impl.UserDetailsServiceImpl;



@Configuration

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired

    private UserDetailsServiceImpl userDetailsService;

            

    @Bean

    public PasswordEncoder passwordEncoder() {

        return new BCryptPasswordEncoder();

    }



    @Override

    @Bean

    public AuthenticationManager authenticationManagerBean() throws Exception {

        return super.authenticationManagerBean();

    }

    @Override

    protected void configure(AuthenticationManagerBuilder auth) throws Exception {

        auth.userDetailsService(userDetailsService)

            .passwordEncoder(passwordEncoder());

    }



    @Override

    public void configure(WebSecurity web) throws Exception {

        web.ignoring().antMatchers("/favor.ioc");

    }



}

（4）配置文件配置

server:

  port: 7006

spring:

  application:

    name: auth

  datasource:

    name: store_service

    type: com.alibaba.druid.pool.DruidDataSource

    druid:

      driver-class-name: com.mysql.jdbc.Driver

      url: jdbc:mysql://127.0.0.1:3306/dys_auth_center?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false

      username: root

      password: root

      initial-size: 5

      min-idle: 5

      max-active: 20

      max-wait: 60000

      time-between-eviction-runs-millis: 60000

      min-evictable-idle-time-millis: 300000

      validation-query: SELECT 'x'

      validation-query-timeout: 6

      test-while-idle: true

      test-on-borrow: false

      test-on-return: false

      pool-prepared-statements: false

      max-pool-prepared-statement-per-connection-size: 20

      filters: stat

      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

mybatis:

  mapper-locations: classpath:mapping/*.xml

  type-aliases-package: com.donwait.model

 

eureka:

  instance:

    prefer-ip-address: true

    registry-fetch-interval-seconds: 30

    lease-renewal-interval-in-seconds: 10

    lease-expiration-duration-in-seconds: 30

  client:

      service-url:

        defaultZone: http://127.0.0.1:7002/eureka/,http://127.0.0.1:7003/eureka/

endpoints:

  health:

    sensitive: false

    enabled: false

  shutdown:

    enabled: true

    path: /shutdown

    sensitive: true

management:

  security:

    enabled: false

security:

  oauth2:

    resource:

      filter-order: 3

logging:

  config: classpath:logback.xml

  level:

    org:

      springframework:

        web: INFO

        security: DEBUG

#actuator:

info:

  author:

    name: 李祥祥

    email:[email protected]

  hostory:

  - date: 2018-08-28 10:10:10

    user:[email protected]

  - date: 2018-07-10 08:30:00

    user:[email protected]

  build:

    artifact: "@project.artifactId@"

    name: "@project.name@"

    version: "@project.version@"

 

（5）启动入口

package com.donwait;



import org.mybatis.spring.annotation.MapperScan;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.client.discovery.EnableDiscoveryClient;



/**

* http://localhost:7006/oauth/authorize?response_type=code&client_id=wx_takeout_client_id&redirect_uri=http://localhost:7010/uaa/login

* @author Administrator

*/

@SpringBootApplication                    // SpringBoot应用

@EnableDiscoveryClient                    // 开启服务发现功能

@MapperScan("com.donwait.mapper")        // 将项目中对应的mapper类的路径加进来就可以了

public class AuthServerApp {



    public static void main(String[] args) {;

        SpringApplication.run(AuthServerApp.class, args);

    }

}

 

（6）redis配置

package com.donwait.redis;



import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.List;



import org.springframework.data.redis.connection.RedisConnection;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.security.oauth2.common.ExpiringOAuth2RefreshToken;

import org.springframework.security.oauth2.common.OAuth2AccessToken;

import org.springframework.security.oauth2.common.OAuth2RefreshToken;

import org.springframework.security.oauth2.provider.OAuth2Authentication;

import org.springframework.security.oauth2.provider.token.AuthenticationKeyGenerator;

import org.springframework.security.oauth2.provider.token.DefaultAuthenticationKeyGenerator;

import org.springframework.security.oauth2.provider.token.TokenStore;

import org.springframework.security.oauth2.provider.token.store.redis.JdkSerializationStrategy;

import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStoreSerializationStrategy;

import org.springframework.stereotype.Component;



import lombok.Data;



@Data

@Component

public class MyRedisTokenStore implements TokenStore {

    private static final String ACCESS = "access:";

    private static final String AUTH_TO_ACCESS = "auth_to_access:";

    private static final String AUTH = "auth:";

    private static final String REFRESH_AUTH = "refresh_auth:";

    private static final String ACCESS_TO_REFRESH = "access_to_refresh:";

    private static final String REFRESH = "refresh:";

    private static final String REFRESH_TO_ACCESS = "refresh_to_access:";

    private static final String CLIENT_ID_TO_ACCESS = "client_id_to_access:";

    private static final String UNAME_TO_ACCESS = "uname_to_access:";

    private final RedisConnectionFactory connectionFactory;

    private AuthenticationKeyGenerator authenticationKeyGenerator = new DefaultAuthenticationKeyGenerator();

    private RedisTokenStoreSerializationStrategy serializationStrategy = new JdkSerializationStrategy();

    private String prefix = "";



    public MyRedisTokenStore(RedisConnectionFactory connectionFactory) {

        this.connectionFactory = connectionFactory;

    }

    

    private byte[] serialize(Object object) {

        return this.serializationStrategy.serialize(object);

    }

    

    private byte[] serializeKey(String object) {

        return this.serialize(this.prefix + object);

    }



    private OAuth2AccessToken deserializeAccessToken(byte[] bytes) {

        return (OAuth2AccessToken)this.serializationStrategy.deserialize(bytes, OAuth2AccessToken.class);

    }

    private OAuth2Authentication deserializeAuthentication(byte[] bytes) {

        return (OAuth2Authentication)this.serializationStrategy.deserialize(bytes, OAuth2Authentication.class);

    }

    private OAuth2RefreshToken deserializeRefreshToken(byte[] bytes) {

        return (OAuth2RefreshToken)this.serializationStrategy.deserialize(bytes, OAuth2RefreshToken.class);

    }

    

    private String deserializeString(byte[] bytes) {

        return this.serializationStrategy.deserializeString(bytes);

    }

    

    private static String getApprovalKey(OAuth2Authentication authentication) {

        String userName = authentication.getUserAuthentication() == null ? "": authentication.getUserAuthentication().getName();

        return getApprovalKey(authentication.getOAuth2Request().getClientId(), userName);

    }

    private static String getApprovalKey(String clientId, String userName) {

        return clientId + (userName == null ? "" : ":" + userName);

    }



    private RedisConnection getConnection() {

        return this.connectionFactory.getConnection();

    }

    

    @Override

    public OAuth2AccessToken getAccessToken(OAuth2Authentication authentication) {

        String key = this.authenticationKeyGenerator.extractKey(authentication);

        byte[] serializedKey = this.serializeKey(AUTH_TO_ACCESS + key);

        byte[] bytes = null;

        RedisConnection conn = this.getConnection();

        try {

            bytes = conn.get(serializedKey);

        } finally {

            conn.close();

        }

        OAuth2AccessToken accessToken = this.deserializeAccessToken(bytes);

        if (accessToken != null) {

            OAuth2Authentication storedAuthentication = this.readAuthentication(accessToken.getValue());

            if (storedAuthentication == null || !key.equals(this.authenticationKeyGenerator.extractKey(storedAuthentication))) {

                this.storeAccessToken(accessToken, authentication);

            }

        }

        return accessToken;

    }

    @Override

    public OAuth2Authentication readAuthentication(OAuth2AccessToken token) {

        return this.readAuthentication(token.getValue());

    }

    @Override

    public OAuth2Authentication readAuthentication(String token) {

        byte[] bytes = null;

        RedisConnection conn = this.getConnection();

        try {

            bytes = conn.get(this.serializeKey("auth:" + token));

        } finally {

            conn.close();

        }

        OAuth2Authentication auth = this.deserializeAuthentication(bytes);

        return auth;

    }

    @Override

    public OAuth2Authentication readAuthenticationForRefreshToken(OAuth2RefreshToken token) {

        return this.readAuthenticationForRefreshToken(token.getValue());

    }

    public OAuth2Authentication readAuthenticationForRefreshToken(String token) {

        RedisConnection conn = getConnection();

        try {

            byte[] bytes = conn.get(serializeKey(REFRESH_AUTH + token));

            OAuth2Authentication auth = deserializeAuthentication(bytes);

            return auth;

        } finally {

            conn.close();

        }

    }

    @Override

    public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {

        byte[] serializedAccessToken = serialize(token);

        byte[] serializedAuth = serialize(authentication);

        byte[] accessKey = serializeKey(ACCESS + token.getValue());

        byte[] authKey = serializeKey(AUTH + token.getValue());

        byte[] authToAccessKey = serializeKey(AUTH_TO_ACCESS + authenticationKeyGenerator.extractKey(authentication));

        byte[] approvalKey = serializeKey(UNAME_TO_ACCESS + getApprovalKey(authentication));

        byte[] clientId = serializeKey(CLIENT_ID_TO_ACCESS + authentication.getOAuth2Request().getClientId());

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.stringCommands().set(accessKey, serializedAccessToken);

            conn.stringCommands().set(authKey, serializedAuth);

            conn.stringCommands().set(authToAccessKey, serializedAccessToken);

            if (!authentication.isClientOnly()) {

                conn.rPush(approvalKey, serializedAccessToken);

            }

            conn.rPush(clientId, serializedAccessToken);

            if (token.getExpiration() != null) {

                int seconds = token.getExpiresIn();

                conn.expire(accessKey, seconds);

                conn.expire(authKey, seconds);

                conn.expire(authToAccessKey, seconds);

                conn.expire(clientId, seconds);

                conn.expire(approvalKey, seconds);

            }

            OAuth2RefreshToken refreshToken = token.getRefreshToken();

            if (refreshToken != null && refreshToken.getValue() != null) {

                byte[] refresh = serialize(token.getRefreshToken().getValue());

                byte[] auth = serialize(token.getValue());

                byte[] refreshToAccessKey = serializeKey(REFRESH_TO_ACCESS + token.getRefreshToken().getValue());

                conn.stringCommands().set(refreshToAccessKey, auth);

                byte[] accessToRefreshKey = serializeKey(ACCESS_TO_REFRESH + token.getValue());

                conn.stringCommands().set(accessToRefreshKey, refresh);

                if (refreshToken instanceof ExpiringOAuth2RefreshToken) {

                    ExpiringOAuth2RefreshToken expiringRefreshToken = (ExpiringOAuth2RefreshToken) refreshToken;

                    Date expiration = expiringRefreshToken.getExpiration();

                    if (expiration != null) {

                        int seconds = Long.valueOf((expiration.getTime() - System.currentTimeMillis()) / 1000L)

                                .intValue();

                        conn.expire(refreshToAccessKey, seconds);

                        conn.expire(accessToRefreshKey, seconds);

                    }

                }

            }

            conn.closePipeline();

        } finally {

            conn.close();

        }

    }

    @Override

    public void removeAccessToken(OAuth2AccessToken accessToken) {

        this.removeAccessToken(accessToken.getValue());

    }

    @Override

    public OAuth2AccessToken readAccessToken(String tokenValue) {

        byte[] key = serializeKey(ACCESS + tokenValue);

        byte[] bytes = null;

        RedisConnection conn = getConnection();

        try {

            bytes = conn.get(key);

        } finally {

            conn.close();

        }

        OAuth2AccessToken accessToken = deserializeAccessToken(bytes);

        return accessToken;

    }

    public void removeAccessToken(String tokenValue) {

        byte[] accessKey = serializeKey(ACCESS + tokenValue);

        byte[] authKey = serializeKey(AUTH + tokenValue);

        byte[] accessToRefreshKey = serializeKey(ACCESS_TO_REFRESH + tokenValue);

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.get(accessKey);

            conn.get(authKey);

            conn.del(accessKey);

            conn.del(accessToRefreshKey);

            // Don't remove the refresh token - it's up to the caller to do that

            conn.del(authKey);

            List results = conn.closePipeline();

            byte[] access = (byte[]) results.get(0);

            byte[] auth = (byte[]) results.get(1);

            OAuth2Authentication authentication = deserializeAuthentication(auth);

            if (authentication != null) {

                String key = authenticationKeyGenerator.extractKey(authentication);

                byte[] authToAccessKey = serializeKey(AUTH_TO_ACCESS + key);

                byte[] unameKey = serializeKey(UNAME_TO_ACCESS + getApprovalKey(authentication));

                byte[] clientId = serializeKey(CLIENT_ID_TO_ACCESS + authentication.getOAuth2Request().getClientId());

                conn.openPipeline();

                conn.del(authToAccessKey);

                conn.lRem(unameKey, 1, access);

                conn.lRem(clientId, 1, access);

                conn.del(serialize(ACCESS + key));

                conn.closePipeline();

            }

        } finally {

            conn.close();

        }

    }

    @Override

    public void storeRefreshToken(OAuth2RefreshToken refreshToken, OAuth2Authentication authentication) {

        byte[] refreshKey = serializeKey(REFRESH + refreshToken.getValue());

        byte[] refreshAuthKey = serializeKey(REFRESH_AUTH + refreshToken.getValue());

        byte[] serializedRefreshToken = serialize(refreshToken);

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.stringCommands().set(refreshKey, serializedRefreshToken);

            conn.stringCommands().set(refreshAuthKey, serialize(authentication));

            if (refreshToken instanceof ExpiringOAuth2RefreshToken) {

                ExpiringOAuth2RefreshToken expiringRefreshToken = (ExpiringOAuth2RefreshToken) refreshToken;

                Date expiration = expiringRefreshToken.getExpiration();

                if (expiration != null) {

                    int seconds = Long.valueOf((expiration.getTime() - System.currentTimeMillis()) / 1000L)

                            .intValue();

                    conn.expire(refreshKey, seconds);

                    conn.expire(refreshAuthKey, seconds);

                }

            }

            conn.closePipeline();

        } finally {

            conn.close();

        }

    }

    @Override

    public OAuth2RefreshToken readRefreshToken(String tokenValue) {

        byte[] key = serializeKey(REFRESH + tokenValue);

        byte[] bytes = null;

        RedisConnection conn = getConnection();

        try {

            bytes = conn.get(key);

        } finally {

            conn.close();

        }

        OAuth2RefreshToken refreshToken = deserializeRefreshToken(bytes);

        return refreshToken;

    }

    @Override

    public void removeRefreshToken(OAuth2RefreshToken refreshToken) {

        this.removeRefreshToken(refreshToken.getValue());

    }

    public void removeRefreshToken(String tokenValue) {

        byte[] refreshKey = serializeKey(REFRESH + tokenValue);

        byte[] refreshAuthKey = serializeKey(REFRESH_AUTH + tokenValue);

        byte[] refresh2AccessKey = serializeKey(REFRESH_TO_ACCESS + tokenValue);

        byte[] access2RefreshKey = serializeKey(ACCESS_TO_REFRESH + tokenValue);

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.del(refreshKey);

            conn.del(refreshAuthKey);

            conn.del(refresh2AccessKey);

            conn.del(access2RefreshKey);

            conn.closePipeline();

        } finally {

            conn.close();

        }

    }

    @Override

    public void removeAccessTokenUsingRefreshToken(OAuth2RefreshToken refreshToken) {

        this.removeAccessTokenUsingRefreshToken(refreshToken.getValue());

    }

    private void removeAccessTokenUsingRefreshToken(String refreshToken) {

        byte[] key = serializeKey(REFRESH_TO_ACCESS + refreshToken);

        List results = null;

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.get(key);

            conn.del(key);

            results = conn.closePipeline();

        } finally {

            conn.close();

        }

        if (results == null) {

            return;

        }

        byte[] bytes = (byte[]) results.get(0);

        String accessToken = deserializeString(bytes);

        if (accessToken != null) {

            removeAccessToken(accessToken);

        }

    }

    public Collection findTokensByClientIdAndUserName(String clientId, String userName) {

        byte[] approvalKey = serializeKey(UNAME_TO_ACCESS + getApprovalKey(clientId, userName));

        List byteList = null;

        RedisConnection conn = getConnection();

        try {

            byteList = conn.lRange(approvalKey, 0, -1);

        } finally {

            conn.close();

        }

        if (byteList == null || byteList.size() == 0) {

            return Collections. emptySet();

        }

        List accessTokens = new ArrayList(byteList.size());

        for (byte[] bytes : byteList) {

            OAuth2AccessToken accessToken = deserializeAccessToken(bytes);

            accessTokens.add(accessToken);

        }

        return Collections. unmodifiableCollection(accessTokens);

    }

    @Override

    public Collection findTokensByClientId(String clientId) {

        byte[] key = serializeKey(CLIENT_ID_TO_ACCESS + clientId);

        List byteList = null;

        RedisConnection conn = getConnection();

        try {

            byteList = conn.lRange(key, 0, -1);

        } finally {

            conn.close();

        }

        if (byteList == null || byteList.size() == 0) {

            return Collections. emptySet();

        }

        List accessTokens = new ArrayList(byteList.size());

        for (byte[] bytes : byteList) {

            OAuth2AccessToken accessToken = deserializeAccessToken(bytes);

            accessTokens.add(accessToken);

        }

        return Collections. unmodifiableCollection(accessTokens);

    }

}

（7）redis密码比对


package com.donwait.redis;



import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import org.springframework.security.crypto.factory.PasswordEncoderFactories;

import org.springframework.security.crypto.password.PasswordEncoder;



/**

* PasswordEncoder密码验证clientId的时候会报错，因为5.0新特性中需要在密码前方需要加上{Xxx}来判别。

* 所以需要自定义一个类，重新BCryptPasswordEncoder的match方法

* MyBCryptPasswordEncoder类是我自定义的一个类，用来重新match方法

* @author Administrator

*/

public class MyBCryptPasswordEncoder extends BCryptPasswordEncoder {

    @Override

    public boolean matches(CharSequence rawPassword, String encodedPassword) {

        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();

        String presentedPassword = passwordEncoder.encode(rawPassword);

        return passwordEncoder.matches(rawPassword, presentedPassword);

    }

}


（8）UserDetailsService接口实现


package com.donwait.service.impl;



import java.util.HashSet;

import java.util.List;

import java.util.Set;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.core.GrantedAuthority;

import org.springframework.security.core.authority.SimpleGrantedAuthority;

import org.springframework.security.core.userdetails.User;

import org.springframework.security.core.userdetails.UserDetails;

import org.springframework.security.core.userdetails.UserDetailsService;

import org.springframework.security.core.userdetails.UsernameNotFoundException;

import org.springframework.stereotype.Service;



import com.donwait.model.Right;

import com.donwait.service.RightService;

import com.donwait.service.UserService;



@Service

public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired

    private UserService userService;                // 用户服务

    @Autowired

    private RightService rightService;                // 权限服务



    @Override

    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {

        // 查找用户

        com.donwait.model.User user = userService.findByUsername(userName);

        if (null == user) {

            throw new UsernameNotFoundException("用户:" + userName + ",不存在!");

        }

        

        // 设置用户权限

        Set grantedAuthorities = new HashSet();

        List rights = rightService.findByUsername(userName);

        for(Right right : rights) {

            GrantedAuthority authority = new SimpleGrantedAuthority(right.getName());

            grantedAuthorities.add(authority);

        }       

        

        // 标识位设置

        boolean enabled = true;                         // 可用性 :true:可用 false:不可用

        boolean accountNonExpired = true;                 // 过期性 :true:没过期 false:过期

        boolean credentialsNonExpired = true;             // 有效性 :true:凭证有效 false:凭证无效

        boolean accountNonLocked = true;                 // 锁定性 :true:未锁定 false:已锁定

        

        return new User(user.getUsername(), user.getPassword(), enabled, accountNonExpired, credentialsNonExpired, accountNonLocked, grantedAuthorities);

    }

}


（9）注销token配置


package com.donwait.endpoint;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.oauth2.provider.endpoint.FrameworkEndpoint;

import org.springframework.security.oauth2.provider.token.ConsumerTokenServices;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;



@FrameworkEndpoint

public class RevokeTokenEndpoint {

    @Autowired

    private ConsumerTokenServices consumerTokenServices;



    @RequestMapping(value = "/oauth/token", method= RequestMethod.DELETE)

    public @ResponseBody

    String revokeToken(String access_token){

        String msg = "";

        if (consumerTokenServices.revokeToken(access_token)){

            msg = "注销成功";

        }else {

            msg = "注销失败";

        }

        return msg;

    }

}


二、资源服务器配置


 


（1）POM配置


<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">


  <modelVersion>4.0.0modelVersion>


  <artifactId>dys_car_serverartifactId>


  <name>车辆服务name>


  <description>提供平台车辆管理、车牌报警等相关服务description>


 


  <parent>


    <groupId>com.donwaitgroupId>


    <artifactId>DYSartifactId>


    <version>0.0.1-SNAPSHOTversion>


  parent>


 


  <dependencies>


     


     <dependency>


          <groupId>com.donwaitgroupId>


          <artifactId>dys_commonartifactId>


          <version>0.0.1-SNAPSHOTversion>


     dependency>


     


     <dependency>


          <groupId>org.springframework.bootgroupId>


          <artifactId>spring-boot-starter-webartifactId>


     dependency>


     


     <dependency>


         <groupId>org.springframework.cloudgroupId>


         <artifactId>spring-cloud-starter-configartifactId>


     dependency>


     


     <dependency>


          <groupId>org.springframework.cloudgroupId>


          <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>


     dependency>


     


     <dependency>


          <groupId>mysqlgroupId>


          <artifactId>mysql-connector-javaartifactId>


     dependency>


     


     <dependency>


          <groupId>org.mybatis.spring.bootgroupId>


          <artifactId>mybatis-spring-boot-starterartifactId>


          <version>1.3.0version>


     dependency> 


    


     <dependency>


          <groupId>com.alibabagroupId>


          <artifactId>druid-spring-boot-starterartifactId>


          <version>1.1.9version>


     dependency>


     <dependency>


       <groupId>com.alibabagroupId>


       <artifactId>druidartifactId>


       <version>1.1.10version>


     dependency>


     


     <dependency>


          <groupId>io.springfoxgroupId>


          <artifactId>springfox-swagger2artifactId>


          <version>2.2.2version>


     dependency>


     <dependency>


          <groupId>io.springfoxgroupId>


          <artifactId>springfox-swagger-uiartifactId>


          <version>2.2.2version>


     dependency>


     


     <dependency>


        <groupId>org.springframework.bootgroupId>


        <artifactId>spring-boot-starter-amqpartifactId>


     dependency>


     


     <dependency>


     <groupId>com.google.protobufgroupId>


     <artifactId>protobuf-javaartifactId>


     <version>3.5.1version>


    dependency>


    


    <dependency>


        <groupId>org.springframework.cloudgroupId>


        <artifactId>spring-cloud-starter-securityartifactId>


    dependency>


    <dependency>


        <groupId>org.springframework.security.oauth.bootgroupId>


        <artifactId>spring-security-oauth2-autoconfigureartifactId>


    dependency>


  dependencies>


 


project>


 


(2)资源服务器配置


package com.donwait.config;



import org.springframework.context.annotation.Configuration;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;

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;



@Configuration

@EnableResourceServer

public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {

    // 改资源服务器id必须在数据库记录中有配置，也就是对应token的用户必须该资源访问权限(密文：test_resource_secret)

    // 例如，我的数据库记录：'wx_takeout_client_id','test_resource_id','$2a$10$I28j9B0T/roapkMEqfIHguARt0GgLyXwC/DOnFwPpXuQ0xTkrd632','user_info','authorization_code,refresh_token,implicit,password','http://localhost:7010/uaa/login','ROLE_ADMIN,ROLE_DEVICE,ROLE_VIDEO',3600,7200,'{\"systemInfo\":\"Atlas System\"}','true'

    // 通过授权模式或简化模式获取的token（对应用户为wx_takeout_client_id）具有访问资源服务器test_resource_id的权限，所以将改资源服务器id要与数据库的对应，否则无法访问

    private static final String DEMO_RESOURCE_ID = "test_resource_id";

    

    /**

     * 以代码形式配置资源服务器id，配置文件配置不生效

     */

    @Override

    public void configure(ResourceServerSecurityConfigurer resources) {

        resources.resourceId(DEMO_RESOURCE_ID).stateless(true);

    }

    

    @Override

    public void configure(HttpSecurity http) throws Exception {

        http

        .authorizeRequests()

        .antMatchers("/add/**")

        .authenticated();

    }

}


（3）控制器


package com.donwait.controller;



import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;



import io.swagger.annotations.Api;

import io.swagger.annotations.ApiOperation;

import lombok.extern.slf4j.Slf4j;



@Slf4j

@Api(value = "车牌服务控制器", description = "提供车牌抓拍搜索等相关接口")

@RestController

public class CarAlarmController {

    

    @ApiOperation(value="增加车牌抓拍报警", notes="上传车牌识别报警信息并入库")

    @RequestMapping("/add/{id}")

    public String add(@PathVariable String id) {

        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        log.debug("授权信息:{}",authentication);        

        return "Add car alarm";

    }

}




（4）程序入口


package com.donwait;



import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;



@SpringBootApplication

@EnableOAuth2Sso

public class CarApp {



    public static void main(String[] args) {

        SpringApplication.run(CarApp.class, args);

    }



}




三、使用流程


（1）使用授权码模式获取token


打开浏览器，输入：http://localhost:7006/oauth/authorize?response_type=code&client_id=wx_takeout_client_id&redirect_uri=http://localhost:7010/uaa/login




 


重定向到登录页面：输入用户名密码


 


29、oauth2.0 资源服务器与授权服务器分离配置_第1张图片


登录成功后重定向到redirect_uri并携带了code授权码


 


29、oauth2.0 资源服务器与授权服务器分离配置_第2张图片


 


使用postman，输入授权码和其他参数，换取token


29、oauth2.0 资源服务器与授权服务器分离配置_第3张图片


 


（2）通过从认证服务器换取的token访问资源服务器


 


使用GET方式，携带上token授权码，授权码放在header中：


29、oauth2.0 资源服务器与授权服务器分离配置_第4张图片


注意：这里必须选择bearer token，这是oauth默认的认证方式，发送后即可返回结果


29、oauth2.0 资源服务器与授权服务器分离配置_第5张图片


 


备注：当然获取token的过程可以使用四种授权模式的任意一种，比如可以使用password模式：


29、oauth2.0 资源服务器与授权服务器分离配置_第6张图片


此处的授权认证的username为client_id密码为client_secret, 登录的用户名是lixx，用户名lixx的密码为dw123456


29、oauth2.0 资源服务器与授权服务器分离配置_第7张图片


 


重点： 另外一种配置方式：


security: 


  oauth2:


    resource:


      filter-order: 3


      id: test_resource_id


      tokenInfoUri: http://localhost:7006/oauth/check_token


      preferTokenInfo: true


      


最后两行改为，不使用tokeninfo验证，使用用户信息验证：


      user-info-uri:http://localhost:7006/user/principal


        prefer-token-info: false


 


此时资源请求方式为： 直接在url后面带上access_token=xxx, 并且头部不使用授权方式：


 


29、oauth2.0 资源服务器与授权服务器分离配置_第8张图片

























你可能感兴趣的:(spring,cloud)






    

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
文章永久免费只为良心
oracle数据库

    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    

    • 

  • spring如何整合druid连接池？
惜.己
springspringjunit数据库javaidea后端xml

    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    

    • 

  • SpringCloudAlibaba—Sentinel(限流)
菜鸟爪哇

    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    

    • 

  • springboot+vue项目实战一-创建SpringBoot简单项目
苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言

    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    

    • 

  • Spring MVC 全面指南：从入门到精通的详细解析
一杯梅子酱
技术栈学习springmvcjava

    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    

    • 

  • Spring Boot中实现跨域请求
BABA8891
springboot后端java

    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    

    • 

  • 博客网站制作教程
2401_85194651
javamaven

    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    

    • 

  • RabbitMQ生产者重复机制与确认机制
java炒饭小能手
java-rabbitmqrabbitmqjava

    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    

    • 

  • 非对称加密算法————RSA理论及详情
hu19930613

    转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
    

    • 

  • 加载资源时报错-ERR_CONNECTION_RESET，需要多次请求才能拿到资源的有效解决方案
Mebius1916
前端开发前端javascriptreact.js前端框架typescriptvue.js

    初次加载资源时无法正常加载，需要多次刷新、请求才能拿到资源的有效解决方案前言在使用cloudinary进行图片上传并获取图片链接作为用户头像时发现，图片链接网址初次加载会报错：ERR_CONNECTION_RESET必须刷新几次才能获取到，原因可能是cloudinary没有国内的节点，而我用的是在新加坡的节点，所以会导致初次加载的时候被重定向。而这个错误会直接导致用户头像无法加载，因为在img中此
    

    • 

  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
屿小夏
java开发语言

    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    

    • 

  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
瑞金彭于晏
springboot后端javaMVCspring数据库

    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    

    • 

  • spring mvc @RequestBody String类型参数
zoyation
spring-mvcspringmvc

    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    

    • 

  • Java -jar 如何在后台运行项目
vincent_hahaha

    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    

    • 

  • spring security中几大组件的作用和执行顺序
阿信在这里
javaspring

    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    

    • 

  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
叶准鑫Natalie

    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    

    • 

  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
网顺技术团队
成品程序项目javavue.js汽车课程设计springboot

    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    

    • 

  • 分布式锁和spring事务管理
暴躁的鱼
锁及事务分布式springjava

    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    

    • 

  • Java面试笔记记录6
今天背八股了吗
java面试笔记

    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    

    • 

  • Sentinel
眼泪落在琴弦
springcloudjavajava

    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    

    • 

  • Spring @Async 深度解读：默认线程池执行器的配置与优化
小码快撩
springjava前端

    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    

    • 

  • Sentinel实时监控不展示问题
朱杰jjj
sentinelsentinel

    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    

    • 

  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
这孩子叫逆
Mybatis笔记mybatis数据库

    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    

    • 

  • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
weixin_34302561
数据库devops大数据

    1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
    

    • 

  • Halo 开发者指南——容器私有化部署
SHENHUANJIE
DockerHalo华为云SWRRegistry

    华为云SWR私有化部署镜像构建dockerbuild-thalo-dev/halo:2.20.0.上传镜像镜像标签sudodockertag{镜像名称}:{版本名称}swr.cn-south-1.myhuaweicloud.com/{组织名称}/{镜像名称}:{版本名称}sudodockertaghalo-dev/halo:2.20.0swr.cn-south-1.myhuaweicloud.co
    

    • 

  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java

    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    

    • 

  • Spring Security静态资源过滤（11）
小黑屋说YYDS
spring

    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    

    • 

  • Spring Security定义多个过滤器链（10）
小黑屋说YYDS
spring

    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    

    • 

  • java 技术 架构 相关文档
圣心
java架构开发语言

    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    

    • 

  • Python国内常用镜像源和使用方法
wfqlt163
Python基础操作python开发语言

    常用的镜像源：1、企业镜像：豆瓣https://pypi.doubanio.com/simple/网易https://mirrors.163.com/pypi/simple/阿里云https://mirrors.aliyun.com/pypi/simple/腾讯云https://mirrors.cloud.tencent.com/pypi/simple2、高校镜像：清华大学（推荐）：https:/
    

    • 

  • 辗转相处求最大公约数
沐刃青蛟
C++漏洞

    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！
 
为此，总结一下以方便日后忘了好查找。
 
1.输入要比较的两个数a,b
 
忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）
 
3.辗转相除（用循环不停的取余，如a%b,直至b=0）
 
4.最后的a为两数的最大公约数
&
    

    • 

  • F5负载均衡会话保持技术及原理技术白皮书
bijian1013
F5负载均衡

    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
    

    • 

  • Object.equals方法：重载还是覆盖
Cwind
javagenericsoverrideoverload

    本文译自StackOverflow上对此问题的讨论。
原问题链接
 
在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问：
“不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：”
pu
    

    • 

  • 初始线程
15700786134

          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。
 
 
       既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下：
public class ShapeFr
    

    • 

  • Linux的tcpdump
被触发
tcpdump

    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。
实用命令实例
默认启动
tcpdump
普通情况下，直
    

    • 

  • 安卓程序listview优化后还是卡顿
肆无忌惮_
ListView

    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。
&nb
    

    • 

  • 扩展easyUI tab控件，添加加载遮罩效果
知了ing
jquery

    (function () {
$.extend($.fn.tabs.methods, {
//显示遮罩
loading: function (jq, msg) {
return jq.each(function () {
var panel = $(this).tabs(&
    

    • 

  • gradle上传jar到nexus
矮蛋蛋
gradle

    原文地址：
https://docs.gradle.org/current/userguide/maven_plugin.html
configurations {
    deployerJars
}
dependencies {
    deployerJars "org.apache.maven.wagon
    

    • 

  • 千万条数据外网导入数据库的解决方案。
alleni123
sqlmysql

    从某网上爬了数千万的数据，存在文本中。
然后要导入mysql数据库。
悲剧的是数据库和我存数据的服务器不在一个内网里面。。
ping了一下， 19ms的延迟。
于是下面的代码是没用的。
ps = con.prepareStatement(sql);
ps.setString(1, info.getYear())............;
ps.exec
    

    • 

  • JAVA IO InputStreamReader和OutputStreamReader
百合不是茶
JAVA.io操作 字符流

    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！：
JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流
 
字节流和字符的难点：a,怎么将读到的数据
    

    • 

  • MO、MT解读
bijian1013
GSM

    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息；
上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
    

    • 

  • 五个JavaScript基础问题
bijian1013
JavaScriptcallapplythisHoisting

    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。
问题1：Scope作用范围
考虑下面的代码： 
(function() {
var a = b = 5;
})();
console.log(b);
什么会被打印在控制台上？ 
回答：
        上面的代码会打印 5。
&nbs
    

    • 

  • 【Thrift二】Thrift Hello World
bit1129
Hello world

    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程
 
1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错
<dependency>

    

    • 

  • 【Avro一】Avro入门
bit1129
入门

    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。
  1. 添加Maven依赖
 
<?xml version="1.0" encoding="UTF-8"?>
<proj
    

    • 

  • 安装nginx+ngx_lua支持WAF防护功能
ronin47

    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
    

    • 

  • java-5.查找最小的K个元素-使用最大堆
bylijinnan
java

    
import java.util.Arrays;
import java.util.Random;
public class MinKElement {
/**
* 5.最小的K个元素
* I would like to use MaxHeap.
* using QuickSort is also OK
*/
public static void
    

    • 

  • TCP的TIME-WAIT
bylijinnan
socket

    原文连接：
http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html
以下为对原文的阅读笔记
说明：
主动关闭的一方称为local end，被动关闭的一方称为remote end
本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket
1、TIME_WA
    

    • 

  • jquery ajax 序列化表单
coder_xpf
Jquery ajax 序列化

     
 checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值
 
<input type="checkbox" name="favor" id="favor" checked="checked"/>
$("#favor&quo
    

    • 

  • Apache集群乱码和最高并发控制
cuisuqiang
apachetomcat并发集群乱码

    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。
最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下：
<Connector maxThreads="300" port="8019" prot
    

    • 

  • websocket
dalan_123
websocket

    一、低延迟的客户端-服务器 和 服务器-客户端的连接
很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。
  通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
    

    • 

  • 菜鸟分析网络执法官
dcj3sjt126com
网络

     
最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题.
OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理.
前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
    

    • 

  • Android相对布局属性全集
dcj3sjt126com
android

    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距
// 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
    

    • 

  • Tomcat内存设置详解
eksliang
jvmtomcattomcat内存设置

    Java内存溢出详解
 
一、常见的Java内存溢出有以下三种：
 
1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。
可以利用JVM提
    

    • 

  • Java6 JVM参数选项
greatwqs
javaHotSpotjvmjvm参数JVM Options

    Java 6 JVM参数选项大全（中文版）
 
作者：Ken Wu
Email: [email protected]
转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！
 
本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
    

    • 

  • weblogic创建JMC
i5land
weblogicjms

    进入 weblogic控制太
1.创建持久化存储
--Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok
2.创建JMS服务器
--Services--Messaging--JMS Servers--new--name随便起--Pers
    

    • 

  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构
justjavac
DHT

    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。
系统包括几个独立的部分：
使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子；
使用 PHP CI 框架开发的简易网站；
搜索引擎目前直接使用的 MySQL，将来可以考虑使
    

    • 

  • sql添加、删除表中的列
macroli
sql

    添加没有默认值：alter table Test add BazaarType char(1)
有默认值的添加列：alter table Test add BazaarType char(1) default(0)
删除没有默认值的列：alter table Test drop COLUMN BazaarType
删除有默认值的列：先删除约束（默认值）alter table Test DRO
    

    • 

  • PHP中二维数组的排序方法
abc123456789cba
排序二维数组PHP

    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level 
    

    • 

  • hive优化之------控制hive任务中的map数和reduce数
superlxw1234
hivehive优化

    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
    

    • 

  • Spring Boot 1.2.4 发布
wiselyman
spring boot

    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。
 
这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。
 
Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
    

    •