贝壳里的沙
贝壳里的沙

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)

        

            

                
    
                    
  • Spring Boot中的响应与分层解耦架构
                        小村学长毕业设计
springboot架构后端
                        
    SpringBoot中的响应与分层解耦架构在SpringBoot框架中，响应与分层解耦架构是两个核心概念，它们共同促进了应用程序的高效性、可维护性和可扩展性。下面将详细探讨这两个方面，包括SpringBoot的响应机制、分层解耦的三层架构以及它们在实际开发中的应用。一、SpringBoot的响应机制SpringBoot的响应机制主要依赖于其内置的Servlet容器（如Tomcat）和SpringM
    
                    
    • 
                    
  • 【异常】SpringAI提示 Failed to download spring-ai-core 无法解析 org.springframework.ai:spring-ai-core:1.0.0-M3
                        本本本添哥
002-进阶开发能力013-AIGC人工智能大模型spring人工智能java
                        
    一、报错内容[WARNING]Failedtodownloadspring-ai-core-1.0.0-M3.jar[https://repo.spring.io/milestone/][WARNING]Failedtodownloadspring-ai-core-1.0.0-M3.jar[https://repo.maven.apache.org/maven2/]无法解析org.springfr
    
                    
    • 
                    
  • SpringBoot中Mybatis记录执行sql日志
                        钝挫力PROGRAMER
springbootmybatissql
                        
    MyBatis默认使用SLF4J作为日志门面，所以需要在项目中选择一个SLF4J兼容的日志实现，比如Logback,Log4j2等。以Logback为例，也是SpringBoot默认日志框架。添加日志依赖：确保pom.xml中包含Logback依赖（SpringBoot项目不用添加logback）：ch.qos.logbacklogback-classic配置Logback：在src/main/r
    
                    
    • 
                    
  • Java面试宝典：说下Spring Bean的生命周期？
                        熊文豪
Java面试宝典java面试springSpringBeanBeanBean的生命周期
                        
    Java面试宝典专栏范围：JAVA基础，面向对象编程（OOP），异常处理，集合框架，JavaI/O，多线程编程，设计模式，网络编程，框架和工具等全方位面试题详解每日更新Java面试宝典专栏：Java面试宝典感兴趣的可以先收藏起来，大家在遇到JAVA面试题等相关问题都可以给我留言咨询，希望帮助更多的人回答重点实例化：Spring容器根据配置文件或注解实例化Bean对象。属性注入：Spring将依赖（
    
                    
    • 
                    
  • 基于 Spring Cloud + Sentinel 的全面流量治理方案
                        power-辰南
java技术架构师成长专栏springcloudsentinelspring流量治理
                        
    一、精准评估系统最大负载1.流量建模历史日志分析流量特征提取业务场景拆解流量模型构建容量预测模型实施方法：使用ELK分析6个月Nginx日志，提取分时/分业务QPS曲线构建典型场景模型：日常流量（正态分布）、促销流量（脉冲模型）、恶意攻击（毛刺识别）容量公式：单实例容量=(CPU核心数*1000ms)/平均RT(ms)2.数据模拟与环境搭建#使用tcpcopy复制生产流量./tcpcopy-x80
    
                    
    • 
                    
  • Spring Boot 架构入门学习指南
                        Just_Paranoid
技术流Clip1024程序员节后端springbootweb应用API
                        
    SpringBoot架构入门学习指南1.什么是SpringBoot2.快速入门3.核心概念3.1自动配置3.2配置管理3.3Profiles4.数据访问4.1使用SpringDataJPA5.目录结构5.1目录结构5.2目录及文件作用6.拓展开发SpringBoot是Spring框架家族中的一员，由于其简洁和高效广受欢迎。本文将带你从入门到精通，逐步探索SpringBoot的架构及其丰富特性。1.
    
                    
    • 
                    
  • Spring Cloud微服务生产级容量评估实战
                        power-辰南
java专栏springcloud微服务spring容量评估
                        
    一、容量评估体系架构业务需求分析流量建模环境仿真分级压测瓶颈分析容量计算配置推荐验证优化二、流量建模与数据模拟2.1流量建模四步法步骤1：生产流量分析#分析Nginx日志获取真实流量特征awk'{print$4,$7,$9}'access.log|awk-F'[:]''{print$1,$5,$7}'|sort|uniq-c|sort-nr>api_distribution.txt#输出示例：14
    
                    
    • 
                    
  • springboot029网上购物商城系统
                        Q_97095639
springboot毕业设计数据库毕业设计课程设计
                        
    版权声明所有作品均为本人原创，提供参考学习使用，如需要源码+数据库+配套文档请移步www.taobysj.com搜索获取技术实现开发语言：Java+vue。框架：后端spingboot+前端vue。模式：B/S。数据库：mysql。开发工具：idea。论文字数：1万左右。数据库表个数：10个左右。运行环境：jdk+idea+mysql。版本不限制，包安装运行！项目优点：前后端分离，注释详细，代码简
    
                    
    • 
                    
  • Spring Boot集成Spring MVC：快速搭建Web应用
                        软件职业规划
springspringspringbootmvc
                        
    在SpringBoot项目中集成SpringMVC是一个非常常见的需求。SpringBoot已经内置了对SpringMVC的支持，因此集成过程相对简单。1.创建SpringBoot项目你可以通过以下方式创建一个SpringBoot项目：使用SpringInitializr（start.spring.io）在线生成项目。使用IDE（如IntelliJIDEA或Eclipse）的SpringBoot插
    
                    
    • 
                    
  • P1508 Likecloud-吃、吃、吃
                        zty郑桐羽呀 『ZTY』主团团长
洛谷算法c++动态规划开发语言数据结构zty
                        
    前言今天zty带来的是P1508Likecloud-吃、吃、吃，大家给个赞呗，zty放寒假的更新呢是会多起来的大概一天三四个吧,zty最近在冲榜大家多加支持先赞后看养成习惯先赞后看养成习惯演示用编译器及其标准DevC++6.7.5RedpandaC++14正文P1508Likecloud-吃、吃、吃题目背景问世间，青春期为何物？答曰：“甲亢，甲亢，再甲亢；挨饿，挨饿，再挨饿！”题目描述正处在某一特
    
                    
    • 
                    
  • Spring Boot 整合 Kafka 详解
                        码农爱java
KafkaKafkaMQSpringBoot微服务中间件1024程序员节
                        
    前言：上一篇分享了Kafka的一些基本概念及应用场景，本篇我们来分享一下在SpringBoot项目中如何使用Kafka。Kafka系列文章传送门Kafka简介及核心概念讲解SpringBoot集成Kafka引入Kafka依赖在项目的pom.xml文件中引入Kafka依赖，如下：org.springframework.cloudspring-cloud-starter-stream-kafka3.1
    
                    
    • 
                    
  • Maven 与 Spring Boot 项目的集成
                        drebander
Mavenmavenspringbootjava
                        
    在Java开发中，Maven和SpringBoot是最常见的工具和框架。Maven用于构建和管理项目的依赖，而SpringBoot提供了简化的Spring应用开发方式。将Maven和SpringBoot集成，可以帮助我们更高效地构建和部署SpringBoot应用。本文将介绍如何将Maven与SpringBoot集成，并通过Maven构建和管理SpringBoot项目。1.什么是SpringBoot
    
                    
    • 
                    
  • 彻底搞懂ScheduledThreadPoolExecutor
                        seven97_top
并发编程java
                        
    前言项目中经常会遇到一些非分布式的调度任务，需要在未来的某个时刻周期性执行。实现这样的功能，我们有多种方式可以选择：Timer类，jdk1.3引入，不推荐。它所有任务都是串行执行的，同一时间只能有一个任务在执行，而且前一个任务的延迟或异常都将会影响到之后的任务。可能会出现任务执行时间过长而导致任务相互阻塞的情况Spring的@Scheduled注解，不是很推荐这种方式底层虽然是用线程池实现，但是有
    
                    
    • 
                    
  • SpringCloud面试题----eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别
                        指尖下的技术
Java面试题springcloudeurekazookeeper
                        
    dEureka和Zookeeper都可以提供服务注册与发现的功能，它们的区别主要体现在以下几个方面：设计理念Eureka：是基于RESTful风格设计的，强调简单、轻量级，旨在为微服务架构提供一种易于使用的服务发现解决方案，注重服务的可用性和灵活性。Zookeeper：最初是为分布式协调而设计的，提供了一种通用的分布式数据管理和协调服务，其功能更侧重于分布式系统中的数据一致性、节点选举、配置管理等
    
                    
    • 
                    
  • SpringCloud面试题
                        御风行云天
面试题大全springcloudspring后端
                        
    SpringCloud面试题1SpringCloud基础与原理1.1什么是SpringCloud？1.2解释SpringCloud中微服务架构的优势。1.3描述SpringCloud与SpringBoot的关系。2服务发现与注册2.1SpringCloud如何实现服务发现和注册？2.2使用Eureka服务注册中心的原因。2.3描述使用Consul或Zookeeper作为服务注册中心的场景。3配置管
    
                    
    • 
                    
  • SpringBoot系列——WebMvcConfigurer介绍
                        OkidoGreen
SpringBoot-原理
                        
    为什么要使用WebMvcConfigurer？WebMvcConfigurer是一个接口，提供很多自定义的拦截器，例如跨域设置、类型转化器等等。可以说此接口为开发者提前想到了很多拦截层面的需求，方便开发者自由选择使用。由于Spring5.0废弃了WebMvcConfigurerAdapter，所以WebMvcConfigurer继承了WebMvcConfigurerAdapter大部分内容。Web
    
                    
    • 
                    
  • 04---java面试八股文——spring-----注解-------10题
                        20250205
Java面试刷题java面试spring
                        
    31、@ComponentScan注解的作用@ComponentScan注解用于指定Spring容器在启动时要扫描的基础包路径，以及要扫描的包路径下应该被自动注册为Springbean的类。具体来说，@ComponentScan注解的作用有以下几个方面：组件扫描：@ComponentScan注解告诉Spring容器在哪些包及其子包下搜索组件，Spring将会自动扫描并注册被特定注解标记的类（如@C
    
                    
    • 
                    
  • vue3 naive ui+java下载文件
                        weixin_42485982
javavue
                        
    java后端代码importorg.springframework.http.HttpHeaders;importorg.springframework.http.MediaType;importorg.springframework.http.ResponseEntity;importorg.springframework.web.bind.annotation.GetMapping;impor
    
                    
    • 
                    
  • 【八股】Spring篇
                        林子漾
八股项目springjava后端
                        
    whySpring?1.使用它的IOC功能，在解耦上达到了配置级别。2.使用它对数据库访问事务相关的封装。3.各种其他组件与Spring的融合，在Spring中更加方便快捷的继承其他一些组件。IoC和DIIOC是InversionofControl的缩写，“控制反转”之意。在没有引入IOC容器之前，对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创
    
                    
    • 
                    
  • SpringBoot Spring MVC
                        深度视觉机器
SpringBootspringboot
                        
    一、初始SpringMVC1.1什么是SpringMVC1、SpringMVC是Spring框架的一部分  SpringMVC是一种轻量级的、基于MVC的Web层应用框架。SpringMVC通过把模型-视图-控制器分离，将Web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
    
                    
    • 
                    
  • 2024年 Java 面试八股文——SpringBoot篇
                        Java技术前沿
面试javaspringboot面试
                        
    目录1.什么是SpringBoot？2.为什么要用SpringBoot3.SpringBoot与SpringCloud区别4.SpringBoot有哪些优点？5.SpringBoot的核心注解是哪个？它主要由哪几个注解组成的？6.SpringBoot支持哪些日志框架？推荐和默认的日志框架是哪个？7.SpringBootStarter的工作原理8.SpringBoot2.X有什么新特性？与1.X有什
    
                    
    • 
                    
  • SpringBoot中实现WebMvcConfigurer，配置跨域无效
                        TNTnine
Springspringbootjava后端
                        
    跨域配置如下：@ConfigurationpublicclassCorsConfigimplementsWebMvcConfigurer{/***跨域配置*-Access-Control-Allow-Origin的介绍：*-https://blog.csdn.net/MicroAnswer/article/details/102913571*-SpringMVC路径匹配规则：*-1、https:/
    
                    
    • 
                    
  • Spring MVC 的核心以及执行流程
                        小马不敲代码
JAVA相关框架springmvcjava
                        
    SpringMVC的核心SpringMVC是Spring框架中的一个重要模块，它采用了经典的MVC（Model-View-Controller）设计模式。MVC是一种软件架构的思想，它将软件按照模型（Model）、视图（View）和控制器（Controller）三个核心组件来划分，以提高应用程序的可维护性、可测试性和可扩展性。•模型（Model）：表示应用程序中的数据和业务逻辑。在SpringMV
    
                    
    • 
                    
  • Spring Boot01(注解、)---java八股
                        凉漠
java八股javaspringboot开发语言
                        
    SpringBoot中常用注解及其底层实现1、@SpringBootApplication注解：@SpringBootApplication注解：这个注解标识了一个SpringBoot工程，它实际上是另外三个注解的组合，这三个注解是：a@SpringBootConfiguration：这个注解实际就是一个@Configuration，表示启动类也是一个配置类b@EnableAutoConfigur
    
                    
    • 
                    
  • 《炸裂！掌握这些 Spring Boot 干货，面试直接 “开挂”！》
                        @孤随
JAVAspringboot面试后端
                        
    SpringBoot重点、面试题及答案详细整理一、SpringBoot重点知识（一）核心概念1.自动配置SpringBoot自动配置基于类路径中的依赖、配置文件以及应用上下文里的Bean情况，借助条件注解来自动设置Spring应用的配置。例如，当类路径中存在spring-data-jpa和数据库驱动时，会自动配置数据源、JPA实体管理器工厂和事务管理器。可通过@EnableAutoConfigur
    
                    
    • 
                    
  • 智能图像处理平台：技术融合与实践的结晶
                        顾北辰20
智能图像处理平台图像处理人工智能
                        
    目录项目目标项目功能用户模块图像处理模块异步任务模块技术栈数据库设计核心功能实现方式图片上传图片处理异步任务项目扩展近日DeepSeek很火，我让他给我出了个小项目练练手，带大家一起做一下，可做为毕业设计参考。在当今数字化时代，图像处理技术广泛应用于各个领域，从医学影像到社交媒体，其重要性不言而喻。本文将介绍一个智能图像处理平台的练手项目，旨在巩固Java、MySQL、SpringBoot、Red
    
                    
    • 
                    
  • ffmpeg-cli-wrapper操作ffmpeg的工具
                        NaughtyBo
视频&流媒体ffmpeg
                        
    学习链接ffmpeg-cli-wrapper-内部封装了操作ffmpeg命令的java类库，它提供了一些类和方法，可以方便地构建和执行ffmpeg命令，而不需要直接操作字符串或进程。并且支持异步执行和进度监听springboot-ffmpeg-m3u8-convertor-gitee代码-springboot+ffmpeg，将视频转换为m3u8格式。支持.mp4|.flv|.avi|.mov|.w
    
                    
    • 
                    
  • Java 基于 SpringBoot+Vue 的动漫平台（附源码，文档）
                        程序员徐师兄
javaspringbootvue.js动漫平台动漫网站
                        
    博主介绍：✌程序员徐师兄、8年大厂程序员经历。全网粉丝12w+、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战*✌文末获取源码联系精彩专栏推荐订阅不然下次找不到哟2022-2024年最全的计算机软件毕业设计选题大全：1000个热门选题推荐✅Java项目精品实战案例《500套》Java微信小程序项目实战《200套》Python项目实战《200套
    
                    
    • 
                    
  • Java程序设计（五）：基于SpringBoot+Vue的苗族文化分享平台的设计与实现
                        人工智能_SYBH
2025年java程序设计javaspringbootvue.js
                        
    1.引言随着互联网技术的发展，文化传承与传播方式发生了巨大的变革。传统文化的传承不再仅依赖于线下活动，而是越来越多地通过数字化平台进行传播。为了促进苗族文化的传承与推广，本文设计并实现了一个基于SpringBoot和Vue的苗族文化分享平台。该平台通过现代化的技术架构，提供了多种功能模块，包括公告管理、文化遗产管理、资源管理、活动管理、跨文化交流等，既为管理员提供便捷的管理工具，也为普通用户提供了
    
                    
    • 
                    
  • 深入了解Spring缓存注解：@Cacheable、@CacheEvict、@CachePut
                        #难得糊涂
spring缓存java
                        
    引言在现代应用程序中，缓存是提高性能和响应速度的重要手段。Spring框架提供了一组强大的缓存注解，其中包括@Cacheable、@CacheEvict和@CachePut。让我们深入了解这些注解的用途和适用场景。Spring缓存的发展Spring3.x基础支持：在Spring3.x版本中，引入了org.springframework.cache.CacheManager接口来实现缓存管理。它提供
    
                    
    • 
                                
  • 辗转相处求最大公约数
                                    沐刃青蛟
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的第一个里程碑版本将在几天后发布，包含许多
    
                                
    •