15. 微服务综合案例3 zuul admin swagger security rabbitMq （2刷）

女爷i 2022-09-08 03:42 7阅读 0赞

# 1. gateway-service #

## pom ##

<dependencies>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    			<version>2.1.0.RELEASE</version>
    		</dependency>
            
    		 
    		starter-config
    
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter</artifactId>
    		</dependency>
            
    		starter-netflix-eureka-client
    	</dependencies>

## yaml 和 enable ##

spring:
      application:
        name: gateway-service
      cloud:
        config:
          uri: http://localhost:8769
          fail-fast: true
      profiles:
        active: pro

@SpringBootApplication
    @EnableZuulProxy
    @EnableEurekaClient

# 2. admin-service #

## pom ##

<dependencies>
    
    		starter-config
            
    		<dependency>
    			<groupId>de.codecentric</groupId>
    			<artifactId>spring-boot-admin-starter-server</artifactId>
    			<version>2.1.0</version>
    		</dependency>
    
    		starter-web
            
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-security</artifactId>
    		</dependency>
            
    		eureka-client
            
    		<dependency> mail
     			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-mail</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.security</groupId>
    			<artifactId>spring-security-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>org.jolokia</groupId>
    			<artifactId>jolokia-core</artifactId>
    		</dependency>
    	</dependencies>

## yaml 和 logback-spring 和 enable ##

spring:
      application:
        name: admin-service
      cloud:
        config:
          uri: http://localhost:8769
          fail-fast: true
      profiles:
        active: pro

G版本 已经不需要配置 turbine了吧

<?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <include resource="org/springframework/boot/logging/logback/base.xml"/>
        <jmxConfigurator/>
    </configuration>

@SpringBootApplication
    @EnableDiscoveryClient
    
    @EnableAdminServer

## 代码 ##

### security 配置 ###

@Configuration
    public class SecuritySecureConfig extends WebSecurityConfigurerAdapter { 
    
        private final String adminContextPath;
    
        public SecuritySecureConfig(AdminServerProperties adminServerProperties) { 
            this.adminContextPath = adminServerProperties.getContextPath();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception { 
            // @formatter:off
            SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
            
            successHandler.setTargetUrlParameter( "redirectTo" );
    
            http.authorizeRequests() //这两个放心，其他都需要权限
                    .antMatchers( adminContextPath + "/assets/**" ).permitAll()
                    .antMatchers( adminContextPath + "/login" ).permitAll()
                    .anyRequest().authenticated()
                    .and() //登录，登录成功的处理
                    .formLogin().loginPage( adminContextPath + "/login" ).successHandler( successHandler ).and() //登出，登出的处理。 基本拦截 csrf
                    .logout().logoutUrl( adminContextPath + "/logout" ).and()
                    .httpBasic().and()
                    .csrf().disable();
            // @formatter:on
        }
    }

### Notifier config ###

//import de.codecentric.boot.admin.server.domain.entities.InstanceRepository;
    //import de.codecentric.boot.admin.server.notify.CompositeNotifier;
    //import de.codecentric.boot.admin.server.notify.Notifier;
    //import de.codecentric.boot.admin.server.notify.RemindingNotifier;
    //import de.codecentric.boot.admin.server.notify.filter.FilteringNotifier;
    //import org.springframework.beans.factory.ObjectProvider;
    //import org.springframework.context.annotation.Bean;
    //import org.springframework.context.annotation.Configuration;
    //import org.springframework.context.annotation.Primary;
    //
    //import java.time.Duration;
    //import java.util.Collections;
    //import java.util.List;
    //
    //@Configuration
    //public class NotifierConfig { 
    //
    // private final InstanceRepository repository;
    // private final ObjectProvider<List<Notifier>> otherNotifiers;
    //
    // public NotifierConfig(InstanceRepository repository, ObjectProvider<List<Notifier>> otherNotifiers) { 
    // this.repository = repository;
    // this.otherNotifiers = otherNotifiers;
    // }
    //
    // @Bean
    // public FilteringNotifier filteringNotifier() { 
    // CompositeNotifier delegate = new CompositeNotifier(otherNotifiers.getIfAvailable(Collections::emptyList));
    // return new FilteringNotifier(delegate, repository);
    // }
    //
    // @Primary
    // @Bean(initMethod = "start", destroyMethod = "stop")
    // public RemindingNotifier remindingNotifier() { 
    // RemindingNotifier notifier = new RemindingNotifier(filteringNotifier(), repository);
    // notifier.setReminderPeriod(Duration.ofMinutes(10));
    // notifier.setCheckReminderInverval(Duration.ofSeconds(10));
    // return notifier;
    // }
    //}

# 3. user-service #

## pom ##

<dependencies>
    		<dependency>
    			<groupId>com.forezp</groupId>
    			<artifactId>common</artifactId>
    			<version>0.0.1-SNAPSHOT</version>
    		</dependency>
            
    		starter-netflix-eureka-client
    
    		
    		starter-config
    
    		
    		starter-web
    
    		
    		starter-openfeign
    
    		
    		
    		starter-actuator
            
    		
    		starter-netflix-hystrix-dashboard
            
    		
    		starter-netflix-hystrix
    
    		
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-sleuth</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-zipkin</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>io.springfox</groupId>
    			<artifactId>springfox-swagger2</artifactId>
    			<version>2.7.0</version>
    		</dependency>
    		<dependency>
    			<groupId>io.springfox</groupId>
    			<artifactId>springfox-swagger-ui</artifactId>
    			<version>2.7.0</version>
    		</dependency>
            
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<scope>runtime</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-jpa</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework.security</groupId>
    			<artifactId>spring-security-jwt</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.security.oauth</groupId>
    			<artifactId>spring-security-oauth2</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-amqp</artifactId>
    		</dependency>
    
    	</dependencies>

## yaml 和 main ##

spring:
      application:
        name: user-service
      cloud:
        config:
          uri: http://localhost:8769
          fail-fast: true
      profiles:
        active: pro
    
    # datasource:
    # driver-class-name: com.mysql.jdbc.Driver
    # url: jdbc:mysql://localhost:3306/spring-cloud-auth?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8
    # username: root
    # password: 123456
    # jpa:
    # hibernate:
    # ddl-auto: create
    # show-sql: true
    #
    # rabbitmq:
    # host: localhost
    # port: 5672
    # username: guest
    # password: guest
    # publisher-confirms: true
    # virtual-host: /

@SpringBootApplication
    @EnableEurekaClient
    
    @EnableFeignClients //feign
    @EnableHystrixDashboard//dashboard
    @EnableHystrix//hystrix
    public class UserServiceApplication { 
    }

*  public.cert

## aop包：保存日志 ##

@Aspect // 进行切割
    @Component //给spring管理
    public class SysLoggerAspect { 
        @Autowired
        private LoggerService loggerService;
    	
        //切的位置
        @Pointcut("@annotation(com.forezp.annotation.SysLogger)")
        public void loggerPointCut() { 
    
        }
    	
        //之前进行操作
        @Before("loggerPointCut()")
        public void saveSysLog(JoinPoint joinPoint) { 
            //得到 反射的自然
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            //得到 放射的方法
            Method method = signature.getMethod();
    		//创建log
            SysLog sysLog = new SysLog();
            //从注解上，得到 SysLogger
            SysLogger sysLogger = method.getAnnotation(SysLogger.class);
            if(sysLogger != null){ 
                //得到：注解上的描述
                sysLog.setOperation(sysLogger.value());
            }
            //请求的方法名 类的路径
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = signature.getName();
            //拼接成 完整的方法
            sysLog.setMethod(className + "." + methodName + "()");
            //请求的参数
            Object[] args = joinPoint.getArgs();
            String params="";
            for(Object o:args){ 
                //对象转成 json，拼接
                params+=JSON.toJSONString(o);
            }
            //如果 参数不为空
            if(!StringUtils.isEmpty(params)) { 
                //设置上参数
                sysLog.setParams(params);
            }
            //设置IP地址
            sysLog.setIp(HttpUtils.getIpAddress());
            //用户名
            String username = UserUtils.getCurrentPrinciple();
            if(!StringUtils.isEmpty(username)) { 
                //设置上用户名
                sysLog.setUsername(username);
            }
            //日志的创建时间
            sysLog.setCreateDate(new Date());
            //保存系统日志
            loggerService.log(sysLog);
        }
    
    }

## feign 到 Uaa ##

@FeignClient(value = "uaa-service",fallback =AuthServiceHystrix.class )
    public interface AuthServiceClient { 
    
        @PostMapping(value = "/oauth/token") //注意路路径 /oauth/token 。第一参数是 header
        JWT getToken(@RequestHeader(value = "Authorization") String authorization, 
                     @RequestParam("grant_type") String type,
                     @RequestParam("username") String username, 
                     @RequestParam("password") String password);
    }

@Component
    public class AuthServiceHystrix implements AuthServiceClient { 
        @Override
        public JWT getToken(String authorization, String type, String username, String password) { 
            System.out.println("--------opps getToken hystrix---------");
            return null;
        }
    }

## config ##

### security ###

@Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class GlobalMethodSecurityConfiguration { 
    
    }

### jwt config ###

@Configuration
    public class JwtConfiguration { 
        @Autowired //jwt token converter
        JwtAccessTokenConverter jwtAccessTokenConverter;
    
        @Bean
        @Qualifier("tokenStore")
        public TokenStore tokenStore() { 
    		// 使用 jwt token存储
            System.out.println("Created JwtTokenStore");
            return new JwtTokenStore(jwtAccessTokenConverter);
        }
    
        @Bean
        protected JwtAccessTokenConverter jwtTokenEnhancer() { 
            //配置 converter
            JwtAccessTokenConverter converter =  new JwtAccessTokenConverter();
            //得到result
            Resource resource = new ClassPathResource("public.cert");
            String publicKey ;
            try { 
                //公钥 = 资源 得到 输入流 copy到数组
                publicKey = new String(FileCopyUtils.copyToByteArray(resource.getInputStream()));
            } catch (IOException e) { 
                throw new RuntimeException(e);
            }
            //公钥赋值
            converter.setVerifierKey(publicKey);
            return converter;
        }
    }

### Rabbit Mq 配置 ###

@Configuration
    public class RabbitConfig { 
    
    
      public   final static String queueName = "spring-boot";
    
        //创建队列
        @Bean
        Queue queue() { 
            return new Queue(queueName, false);
        }
    	
        //创建交换器
        @Bean
        TopicExchange exchange() { 
            return new TopicExchange("spring-boot-exchange");
        }
    	
        //把队列绑定到交换器
        @Bean
        Binding binding(Queue queue, TopicExchange exchange) { 
            return BindingBuilder.bind(queue).to(exchange).with(queueName);
        }
    
    
    }

### ResourceServerConfigurerAdapter ###

@Configuration
    @EnableResourceServer //开启资源 server
    public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter{ 
        Logger log = LoggerFactory.getLogger(ResourceServerConfiguration.class);
    
        @Override
        public void configure(HttpSecurity http) throws Exception { 
            http
                    .csrf().disable() //禁用csrf
                    .authorizeRequests()
                    .regexMatchers(".*swagger.*",".*v2.*",".*webjars.*","/user/login.*","/user/registry.*","/user/test.*",".*actuator.*").permitAll()//这些放开权限，其他都 要授权
                    .antMatchers("/**").authenticated();
    // .antMatchers("/**").permitAll();
        }
    
    
        @Override //资源ID为 user-service ，token 为 tokenStore
        public void configure(ResourceServerSecurityConfigurer resources) throws Exception { 
            log.info("Configuring ResourceServerSecurityConfigurer ");
            resources.resourceId("user-service").tokenStore(tokenStore);
        }
    
        @Autowired
        TokenStore tokenStore;
    }

### swagger2 配置 ###

@Configuration
    @EnableSwagger2
    public class SwaggerConfig { 
        /** * 全局参数 * * @return */
        private List<Parameter> parameter() { 
            //创建list
            List<Parameter> params = new ArrayList<>();
            //增加 arameterBuilder ，name desc modelRef 参数类型 是否必须，进行构建
            params.add(new ParameterBuilder().name("Authorization")
                    .description("Authorization Bearer token")
                    .modelRef(new ModelRef("string"))
                    .parameterType("header")
                    .required(false).build());
            return params;
        }
    
    
        @Bean //创建 Docket
        public Docket sysApi() { 
            //new Docket ，swagger2 ，apiInfo select apis 路径 构建 全局的参数
            return new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())
                    .select()
                    .apis(RequestHandlerSelectors.basePackage("com.forezp.web"))
                    .paths(PathSelectors.any())
                    .build().globalOperationParameters(parameter());
                    //.securitySchemes(newArrayList(oauth()))
                   // .securityContexts(newArrayList(securityContext()));
        }
    	
        //api info ，ApiInfoBuilder 参数有 title desc termsOfServiceceUrl contact version 
        private ApiInfo apiInfo() { 
            return new ApiInfoBuilder()
                    .title(" user-service api ")
                    .description("user-service 微服务")
                    .termsOfServiceUrl("")
                    .contact("forezp")
                    .version("1.0")
                    .build();
        }
    
    }

## dao dto entiry exception service 包 ##

public interface UserDao extends JpaRepository<User, Long> { 
    
    	User findByUsername(String username);
    }

### dto ###

public class LoginDTO { 
        private User user;
        private String token;
    }

### entity ###

public class JWT { 
        private String access_token;
        private String token_type;
        private String refresh_token;
        private int expires_in;
        private String scope;
        private String jti;
        }

###  ###

public class SysLog { 
    
        private Long id;
        //用户名
        private String username;
        //用户操作
        private String operation;
        //请求方法
        private String method;
        //请求参数
        private String params;
        //IP地址
        private String ip;
        //创建时间
        private Date createDate;
    
    }

@Entity
    public class User implements Serializable { 
    	@Id
    	@GeneratedValue(strategy = GenerationType.IDENTITY)
    	private Long id;
    
    	@Column(nullable = false,  unique = true)
    	private String username;
    
    	@Column
    	private String password;
    	public User() { 
    	}
    
    }

### exception ###

@ControllerAdvice //当做是 controller
    @ResponseBody //json返回
    public class CommonExceptionHandler { 
    	//异常处理
        @ExceptionHandler(CommonException.class)
        public ResponseEntity<RespDTO> handleException(Exception e) { 
            //返回对象。common项目的
            RespDTO resp = new RespDTO();
            //转换成 通用异常
            CommonException taiChiException = (CommonException) e;
            //返回的状态码
            resp.code = taiChiException.getCode();
            //返回的错误码
            resp.error = e.getMessage();
    		//进行返回，状态为200
            return new ResponseEntity(resp, HttpStatus.OK);
        }
    
    }

### service ###

@Service
    public class LoggerService { 
    
        @Autowired
        private AmqpTemplate rabbitTemplate;
    
        public void log(SysLog sysLog){ 
            //发送 日志到 mq，类型为 json
            rabbitTemplate.convertAndSend(RabbitConfig.queueName, JSON.toJSONString(sysLog));
        }
    }

@Service
    public class UserService { 
    
        @Autowired
        UserDao userDao;
        @Autowired
        AuthServiceClient authServiceClient;
    
        //创建用户
        public User createUser(User user){ 
          return  userDao.save(user);
        }
    	//根据用户名查询
        public User getUserInfo(String username){ 
            return userDao.findByUsername(username);
        }
        //登录用户 
        public RespDTO login(String username , String password){ 
            //查询到 用户名
           User user= userDao.findByUsername(username);
           if(null==user){ 
               throw new CommonException(ErrorCode.USER_NOT_FOUND);
           }
            //如果库里的密码 和 参数的明文密码 不匹配，报错
           if(!BPwdEncoderUtils.matches(password,user.getPassword())){ 
               throw new CommonException(ErrorCode.USER_PASSWORD_ERROR);
           }
    		
            //基础token的，创建成 jwt
            JWT jwt = authServiceClient.getToken("Basic dWFhLXNlcnZpY2U6MTIzNDU2", "password", username, password);
            // 获得用户菜单
            if(null==jwt){ 
                throw new CommonException(ErrorCode.GET_TOKEN_FAIL);
            }
            //创建参数赋值
            LoginDTO loginDTO=new LoginDTO();
            loginDTO.setUser(user);
            //设置上 token
            loginDTO.setToken(jwt.getAccess_token());
            return RespDTO.onSuc(loginDTO);
        }
    }

## controller ##

@RestController
    @RequestMapping("/user")
    public class UserController { 
    
        @Autowired
        UserService userService;
    
        @ApiOperation(value = "注册", notes = "username和password为必选项")
        @PostMapping("/registry")
        @SysLogger("registry") //注解，保存日志
        public User createUser(@RequestBody User user){ 
            //参数判读省略,判读该用户在数据库是否已经存在省略。加密 入库
            String entryPassword= BPwdEncoderUtils.BCryptPassword(user.getPassword());
            user.setPassword(entryPassword);
            return userService.createUser(user);
        }
    
        @ApiOperation(value = "登录", notes = "username和password为必选项")
        @PostMapping("/login")
        @SysLogger("login") //登录
        public RespDTO login(@RequestParam String username , @RequestParam String password){ 
            //参数判读省略
          return   userService.login(username,password);
        }
    
        @ApiOperation(value = "根据用户名获取用户", notes = "根据用户名获取用户")
        @PostMapping("/{username}")
        @PreAuthorize("hasRole('USER')") //必须有 user权限
        @SysLogger("getUserInfo")
       // @PreAuthorize("hasAnyAuthority('ROLE_USER')")
        public RespDTO getUserInfo(@PathVariable("username") String username){ 
            //参数判读省略
            User user=  userService.getUserInfo(username);
            return RespDTO.onSuc(user);
        }
    
    // @Autowired
    // private AmqpTemplate rabbitTemplate;
    // @GetMapping("/test")
    // public void test(){ 
    // rabbitTemplate.convertAndSend(RabbitConfig.queueName, "Hello from RabbitMQ!");
    // }
    }

## util包 ##

### b crypt password encoder ###

public class BPwdEncoderUtils { 
    	//创建 
        private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
    
        /** * 用BCryptPasswordEncoder 加密 * @param password * @return */
        public static String  BCryptPassword(String password){ 
            return encoder.encode(password);
        }
    
        /** * * @param rawPassword 原始密码 。明文。String * @param encodedPassword 加密后的密码。 库里的 密文 * @return */
        public static boolean matches(CharSequence rawPassword, String encodedPassword){ 
            return encoder.matches(rawPassword,encodedPassword);
        }
    
    }

### httpUtils ###

public class HttpUtils { 
    
    
        /** * 尝试获取当前请求的HttpServletRequest实例 * * @return HttpServletRequest */
        public static HttpServletRequest getHttpServletRequest() { 
            try { 
                //RequestContextHolder.getRequestAttributes()
                return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            } catch (Exception e) { 
                return null;
            }
        }
    
    	
        public static Map<String, String> getHeaders(HttpServletRequest request) { 
            //创建 map
            Map<String, String> map = new LinkedHashMap<>();
            //从请求中 获取 headerNames
            Enumeration<String> enumeration = request.getHeaderNames();
            //如果存在 进行遍历
            while (enumeration.hasMoreElements()) { 
                //获得到 key
                String key = enumeration.nextElement();
                //request中 通过key获得 到值
                String value = request.getHeader(key);
                //放入map
                map.put(key, value);
            }
            return map;
        }
    
        /** * 获取请求客户端的真实ip地址 * * @param request 请求对象 * @return ip地址 */
        public static String getIpAddress(HttpServletRequest request) { 
    
            // 获取请求主机IP地址,如果通过代理进来，则透过防火墙获取真实IP地址
            String ip = request.getHeader("X-Forwarded-For");
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
                if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
                    ip = request.getHeader("Proxy-Client-IP");
                }
                if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
                    ip = request.getHeader("WL-Proxy-Client-IP");
                }
                if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
                    ip = request.getHeader("HTTP_CLIENT_IP");
                }
                if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
                    ip = request.getHeader("HTTP_X_FORWARDED_FOR");
                }
                if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
                    //获得远程的IP
                    ip = request.getRemoteAddr();
                }
            } else if (ip.length() > 15) { 
                String[] ips = ip.split(",");
                for (int index = 0; index < ips.length; index++) { 
                    String strIp = (String) ips[index];
                    if (!("unknown".equalsIgnoreCase(strIp))) { 
                        ip = strIp;
                        break;
                    }
                }
            }
            return ip;
        }
    
        /** * 获取请求客户端的真实ip地址 * * @param * @return ip地址 */
        public static String getIpAddress() { 
            // 获取请求主机IP地址,如果通过代理进来，则透过防火墙获取真实IP地址
            return getIpAddress(getHttpServletRequest());
        }
    
    
    }

### User Utils ###

public class UserUtils { 
    	//定义 token 头
        private static final String AUTHORIZATION = "authorization";
    
        /** * 获取当前请求的token * @return */
        public static String getCurrentToken() { 
            //获得 所有 headers头 ，在获得这个 token 头
            return HttpUtils.getHeaders(HttpUtils.getHttpServletRequest()).get(AUTHORIZATION);
        }
    
        /** * 获取当前请求的用户Id * @return */
        public static String getCurrentPrinciple() { 
            //security上下文，获得 上下文，获得 认证信息，获得 getPrincipal
            return (String) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        }
    
        /** * 判读当前token用户是否为接口所需的参数username * * @param username * @return */
        public static boolean isMyself(String username) { 
            //判断 当前登录的用户，是否和 参数的user name 相同
            return username.equals(getCurrentPrinciple());
        }
    
        /** * 获取当前请求Authentication * * @return */
        public static Authentication getCurrentAuthentication() { 
            return SecurityContextHolder.getContext().getAuthentication();
        }
    
        /** * 获取当前请求的权限信息 * @return */
        public static List<SimpleGrantedAuthority> getCurrentAuthorities() { 
            //获得认证信息，在调用 getAuthorities() 获权限
            return (List<SimpleGrantedAuthority>) SecurityContextHolder.getContext().getAuthentication().getAuthorities();
        }
    
        /** * @param role 是否包含某个权限 * @return */
        public static boolean hasRole(String role) { 
            //如果不是 ROLE 开头的，就 拼接
            if (!role.startsWith("ROLE_")) { 
                role = "ROLE_" + role;
            }
            //默认不包含权限
            boolean hasRole = false;
            //获得所有的权限
            List<SimpleGrantedAuthority> list = getCurrentAuthorities();
            //遍历
            for (SimpleGrantedAuthority s : list) { 
               	//如果角色 包含这个权限，就返回true
                if (role.equals(s.getAuthority())) { 
                    hasRole = true;
                    break;
                }
            }
            return hasRole;
        }
    
    }