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

最新推荐文章于 2022-12-21 11:09:20 发布

笨_鸟_不_会_飞

最新推荐文章于 2022-12-21 11:09:20 发布

阅读量1.4w

点赞数 1

分类专栏： spring cloud 权限架构/管理文章标签： spring cloud spring boot 分布式高并发

本文链接：https://blog.csdn.net/linzhefeng89/article/details/79315576

版权

spring boot 同时被 3 个专栏收录

84 篇文章 2 订阅

订阅专栏

java

65 篇文章 5 订阅

订阅专栏

spring cloud

21 篇文章 0 订阅

订阅专栏

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

在我们的鉴权中心的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/> <!-- lookup parent from repository -->
	</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>

		<!-- 添加对spring-redis的支持 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-redis</artifactId>
			<version>1.3.8.RELEASE</version>
		</dependency>

		<!-- 引入mybatis的支持 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.1</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>

		<!--Gson-->
		<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

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

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

QQ交流群：578746866