基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（五）【构建鉴权中心】

「爱情、让人受尽委屈。」 2022-05-31 07:50 49阅读 0赞

微服务架构的内部调用理论上是无状态的，微服务之间理论上是可以相互调用，如果是无状态的那么我们为什么还需要鉴权中心呢，很明显鉴权中心不是给内部的微服务架构使用的，鉴权中心实际上是给我们的路由中心使用的，我们只在我们的路由网关暴露公网访问的权限，我们的内部的微服务对公网是完全隔离的，因此公网上是无法访问到我们的内部的微服务，公网只能访问到我们的路由网关，因此我们只要在路由网关处做好权限拦截就可以大功告成了，路由网关的设置将在下一节进行配置，首先我们创建一个modules如下所示。

![2018021214104871][]

在我们的鉴权中心的pom.xml文件引入如下的依赖：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.authentication.center</groupId>
    	<artifactId>authentication-center</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>authentication-center</name>
    	<description>鉴权中心</description>
    
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>1.5.9.RELEASE</version>
    		<relativePath/> 
    	</parent>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    		<java.version>1.8</java.version>
    	</properties>
    
    	<dependencies>
    
    		<dependency>
    			<groupId>com.base</groupId>
    			<artifactId>model</artifactId>
    			<version>[0.0.1-SNAPSHOT,)</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-eureka</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-feign</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-zipkin</artifactId>
    			<version>RELEASE</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-redis</artifactId>
    			<version>1.3.8.RELEASE</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.mybatis.spring.boot</groupId>
    			<artifactId>mybatis-spring-boot-starter</artifactId>
    			<version>1.3.1</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>${mysql.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>com.google.code.gson</groupId>
    			<artifactId>gson</artifactId>
    		</dependency>
    
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>Edgware.RELEASE</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    
    </project>

鉴权中心说白了就是一个生产者，是给其他消费者进行调用的因此鉴权中心需要给鉴权中心的启动类增加（@EnableDiscoveryClient）注解让其成为一个生产者可以给其他消费者调用，同时大家也要记得注入我们在第二章中写的工具类RedisCache：

package com.authentication.center;
    
    import com.base.util.redis.RedisCache;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.context.annotation.Bean;
    
    @SpringBootApplication
    @EnableDiscoveryClient
    public class AuthenticationCenterApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(AuthenticationCenterApplication.class, args);
    	}
    
    	/**
    	 * 注入RedisCache工具类
    	 * @return
    	 */
    	@Bean
    	public RedisCache redisCache(){
    		return new RedisCache();
    	}
    }

接着在我们的resource底下创建我们的application-prod.properties配置文件该配置文件如下：

spring.application.name=authentication-service
    # 注册中心地址
    eureka.client.serviceUrl.defaultZone=http://fjhyll:hyll-2.0@127.0.0.1:2100/eureka/
    # 链路数据收集并发送地址
    spring.zipkin.base-url=http://127.0.0.1:9100
    # 当前应用收集信息百分比
    spring.sleuth.sampler.percentage=0.1
    # 鉴权中心端口号
    server.port=6100
    
    # redis配置文件
    spring.redis.host=10.6.71.236
    spring.redis.port=6379
    spring.redis.pool.max-idle=20
    
    spring.datasource.driverClassName=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://10.6.71.236:3306/hyll_springboot?characterEncoding=utf-8
    spring.datasource.username=root
    spring.datasource.password=haoyunll123
    #连接池的配置信息
    #初始化连接数
    spring.datasource.initialSize=5  
    #最小空闲连接数
    spring.datasource.minIdle=5  
    #最大连接数
    spring.datasource.maxActive=200 
    #
    spring.datasource.maxWait=60000  
    spring.datasource.timeBetweenEvictionRunsMillis=60000  
    spring.datasource.minEvictableIdleTimeMillis=300000  
    spring.datasource.validationQuery=SELECT 1 FROM DUAL  
    spring.datasource.testWhileIdle=true  
    spring.datasource.testOnBorrow=false  
    spring.datasource.testOnReturn=false  
    spring.datasource.poolPreparedStatements=true  
    spring.datasource.maxPoolPreparedStatementPerConnectionSize=20  
    spring.datasource.filters=stat,wall,log4j  
    spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

接着我们编写我们的实现鉴权的controller类如下：

package com.authentication.center.controller;
    
    import com.base.entity.Identify;
    import com.base.entity.User;
    import com.base.util.redis.RedisCache;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /*
    * 类描述：鉴权中心业务处理类controller
    * @auther linzf
    * @create 2018/02/12 0024
    */
    @RestController
    public class AuthenticationController {
    
        @Autowired
        private RedisCache redisCache;
    
        @RequestMapping(value = "/identify", method= RequestMethod.POST)
        public  Map<String,Object> identify(@RequestBody Identify identify){
            Map<String,Object> result = new HashMap<String, Object>();
            result.put("result",false);
            result.put("msg","用户非法登陆");
            if(identify !=null&& identify.getToken()!=null&&!identify.getToken().equals("")&& identify.getIp()!=null&&!identify.getIp().equals("")){
                System.out.println("鉴权中心收到的token的值是："+ identify.getIp()+"--"+ identify.getToken());
                User user = redisCache.getObject(identify.getIp()+"-"+ identify.getToken(),User.class);
                if(user==null){
                    result.put("result",false);
                    result.put("msg","用户未登陆，请重新登陆以后再操作！");
                    return result;
                }
                result.put("result",true);
                result.put("msg","权限鉴定通过");
            }
            return result;
        }
    
    }

这里重点和大家讲解下鉴权中心的鉴权的逻辑，首先用户在登陆成功的时候，系统会获取当前登陆用户的IP与相应的token

组合作为key，用户登陆信息作为value保存在redis内存数据库中，每次用户通过路由网关调用的请求都会携带token信息，路由网关获取用户的token信息以及真实IP调用鉴权中心鉴权接口，鉴权中心根据路由网关提供的token和真实IP去redis内存数据库去查找我们的用户信息，若查到则表面该用户已经登陆成功了，那么该用户就可以接着走正常的业务流程，反之则告知用户没有权限访问，该鉴权中心只验证了用户是否登陆，但是并没有根据用户的权限进行拦截，因此大家可以在此工程的基础上对权限进行拦截。

到此我们完成了我们鉴权中心的配置，这时候我们可以把我们前面的注册中心启动起来，然后再启动我们的鉴权中心，大家可以看到在注册中心上已经显示了我们的鉴权中心了。

到此为止的GitHub项目地址：[https://github.com/185594-5-27/spring-cloud-rbac/tree/master-authentica][https_github.com_185594-5-27_spring-cloud-rbac_tree_master-authentica]

上一篇文章地址：[基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（四）【构建链路调用监控系统】][springboot_redis_bootstrap_mysql_springcloud]

下一篇文章地址：[基于springboot+redis+bootstrap+mysql开发一套属于自己的分布式springcloud云权限架构（六）【权限架构生产者（通用类编写）】][springboot_redis_bootstrap_mysql_springcloud 1]

QQ交流群：578746866

[2018021214104871]: /images/20220531/13f28f70977246fd99de5d71cf882f3d.png
[https_github.com_185594-5-27_spring-cloud-rbac_tree_master-authentica]: https://github.com/185594-5-27/spring-cloud-rbac/tree/master-authentica
[springboot_redis_bootstrap_mysql_springcloud]: http://blog.csdn.net/linzhefeng89/article/details/79314910
[springboot_redis_bootstrap_mysql_springcloud 1]: http://blog.csdn.net/linzhefeng89/article/details/79315576