Spring Boot 통합 Shiro 동적 로드 권한 구현 전체 절차

머리말
본 고 는 SpringBoot 통합 Shiro 를 바탕 으로 동적 uri 권한 을 실현 하고 전단 vue 에서 페이지 에 uri,자바 백 엔 드 동적 새로 고침 권한 을 설정 합 니 다.프로젝트 를 다시 시작 하지 않 아 도 되 고 페이지 에서 사용자 역할,버튼,uri 권한 을 분배 한 후에 백 엔 드 동적 으로 권한 을 분배 합 니 다.사용 자 는 페이지 에 다시 로그 인하 지 않 아 도 최신 권한 을 얻 을 수 있 습 니 다.모든 권한 을 동적 으로 불 러 오고 유연 하 게 설정 할 수 있 습 니 다.
기본 환경

spring-boot 2.1.7

mybatis-plus 2.1.0

mysql 5.7.24

redis 5.0.5

따뜻 한 팁:사례 demo 소스 코드 는 글 의 끝 에 붙 어 있 습 니 다.필요 한 친구 들 이 참고 하 세 요~
2.SpringBoot 통합 Shiro
1.관련 maven 의존 도입

<properties>
 <shiro-spring.version>1.4.0</shiro-spring.version>
 <shiro-redis.version>3.1.0</shiro-redis.version>
</properties>
<dependencies>
 <!-- AOP  ,    ,            【 ：          】 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-aop</artifactId>
 </dependency>
 <!-- Redis -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
 </dependency>
 <!-- Shiro      -->
 <dependency>
 <groupId>org.apache.shiro</groupId>
 <artifactId>shiro-spring</artifactId>
 <version>${shiro-spring.version}</version>
 </dependency>
 <!-- Shiro-redis   -->
 <dependency>
 <groupId>org.crazycake</groupId>
 <artifactId>shiro-redis</artifactId>
 <version>${shiro-redis.version}</version>
 </dependency>
</dependencies>

2.사용자 정의 Realm

doGetAuthenticationInfo:인증(주로 로그 인 할 때 논리 적 처리)

doGetAuthorizationInfo:로그 인 인증 성공 후 처리 ex:캐릭터 와 권한 부여
[비고:사용자 가 권한 검증 을 할 때 Shiro 는 캐 시 에서 찾 습 니 다.데 이 터 를 찾 지 못 하면 doGetAuthorizationInfo 라 는 방법 으로 권한 을 찾 아 캐 시 에 넣 습 니 다]->따라서 전단 페이지 에서 사용자 권한 을 할당 할 때 shiro 캐 시 를 제거 하 는 방법 을 실행 하면 동적 할당 사용자 권한

을 실현 할 수 있 습 니 다.

@Slf4j
public class ShiroRealm extends AuthorizingRealm {

 @Autowired
 private UserMapper userMapper;
 @Autowired
 private MenuMapper menuMapper;
 @Autowired
 private RoleMapper roleMapper;

 @Override
 public String getName() {
 return "shiroRealm";
 }

 /**
 *        :          Shiro      ,       ,           ,      
 */
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
 SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
 //     
 User user = (User) principalCollection.getPrimaryPrincipal();
 Integer userId =user.getId();
 //            
 Set<String> rolesSet = new HashSet<>();
 Set<String> permsSet = new HashSet<>();
 //            (          )
 List<Role> roleList = roleMapper.selectRoleByUserId( userId );
 for (Role role:roleList) {
  rolesSet.add( role.getCode() );
  List<Menu> menuList = menuMapper.selectMenuByRoleId( role.getId() );
  for (Menu menu :menuList) {
  permsSet.add( menu.getResources() );
  }
 }
 //             authorizationInfo 
 authorizationInfo.setStringPermissions(permsSet);
 authorizationInfo.setRoles(rolesSet);
 log.info("---------------          ！ ---------------");
 return authorizationInfo;
 }

 /**
 *      -          
 */
 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
 UsernamePasswordToken tokenInfo = (UsernamePasswordToken)authenticationToken;
 //          
 String username = tokenInfo.getUsername();
 //          
 String password = String.valueOf( tokenInfo.getPassword() );

 //   username        User  ，        
 //      ,             ,    ,Shiro           ,2            
 User user = userMapper.selectUserByUsername(username);
 //         
 if (user == null) {
  //  null -> shiro              
  return null;
 }
 //      【 ：     shiro       ，                 ，            ！     ，                】
 if ( !password.equals( user.getPwd() ) ){
  throw new IncorrectCredentialsException("         ");
 }

 //          
 if (user.getFlag()==null|| "0".equals(user.getFlag())){
  throw new LockedAccountException();
 }
 /**
  *      ->  ：shiro       
  *   1：principal ->                       
  *   2：hashedCredentials ->   
  *   3：credentialsSalt ->     
  *   4：realmName ->     Realm
  */
 SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user, user.getPassword(), ByteSource.Util.bytes(user.getSalt()), getName());
 //         (     Session)
 ShiroUtils.deleteCache(username,true);

 //        token
 String token = ShiroUtils.getSession().getId().toString();
 user.setToken( token );
 userMapper.updateById(user);
 return authenticationInfo;
 }

}

3.Shiro 설정 클래스

@Configuration
public class ShiroConfig {

 private final String CACHE_KEY = "shiro:cache:";
 private final String SESSION_KEY = "shiro:session:";
 /**
 *       30  ，  30               ，          
 */
 private final int EXPIRE = 1800;

 /**
 * Redis  
 */
 @Value("${spring.redis.host}")
 private String host;
 @Value("${spring.redis.port}")
 private int port;
 @Value("${spring.redis.timeout}")
 private int timeout;
// @Value("${spring.redis.password}")
// private String password;

 /**
 *   Shiro-aop    ：                
 */
 @Bean
 public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
 AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
 authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
 return authorizationAttributeSourceAdvisor;
 }

 /**
 * Shiro    
 */
 @Bean
 public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager, ShiroServiceImpl shiroConfig){
 ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
 shiroFilterFactoryBean.setSecurityManager(securityManager);

 //       
 Map<String, Filter> filtersMap = new LinkedHashMap<>();
 //         【 ：map  key    value  authc           】
 filtersMap.put( "zqPerms", new MyPermissionsAuthorizationFilter() );
 filtersMap.put( "zqRoles", new MyRolesAuthorizationFilter() );
 filtersMap.put( "token", new TokenCheckFilter() );
 shiroFilterFactoryBean.setFilters(filtersMap);

 //      :                  -                      "/login.jsp"     "/login"   
 shiroFilterFactoryBean.setLoginUrl("/api/auth/unLogin");
 //             （    ，  vue     ）
// shiroFilterFactoryBean.setSuccessUrl("/index");
 //           url
 shiroFilterFactoryBean.setUnauthorizedUrl("/api/auth/unauth");

 shiroFilterFactoryBean.setFilterChainDefinitionMap( shiroConfig.loadFilterChainDefinitionMap() );
 return shiroFilterFactoryBean;
 }

 /**
 *      
 */
 @Bean
 public SecurityManager securityManager() {
 DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
 //    session  
 securityManager.setSessionManager(sessionManager());
 //    Cache      
 securityManager.setCacheManager(cacheManager());
 //    Realm  
 securityManager.setRealm(shiroRealm());
 return securityManager;
 }

 /**
 *      
 */
 @Bean
 public ShiroRealm shiroRealm() {
 ShiroRealm shiroRealm = new ShiroRealm();
 shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
 return shiroRealm;
 }

 /**
 *    Realm      ->      ：       Shiro SimpleAuthenticationInfo    ,        
 */
 @Bean
 public HashedCredentialsMatcher hashedCredentialsMatcher() {
 HashedCredentialsMatcher shaCredentialsMatcher = new HashedCredentialsMatcher();
 //     :    SHA256  ;
 shaCredentialsMatcher.setHashAlgorithmName(SHA256Util.HASH_ALGORITHM_NAME);
 //      ，      ，    md5(md5(""));
 shaCredentialsMatcher.setHashIterations(SHA256Util.HASH_ITERATIONS);
 return shaCredentialsMatcher;
 }

 /**
 *   Redis   ：    shiro-redis    
 */
 @Bean
 public RedisManager redisManager() {
 RedisManager redisManager = new RedisManager();
 redisManager.setHost(host);
 redisManager.setPort(port);
 redisManager.setTimeout(timeout);
// redisManager.setPassword(password);
 return redisManager;
 }

 /**
 *   Cache   ：   Redis          (    shiro-redis    )
 */
 @Bean
 public RedisCacheManager cacheManager() {
 RedisCacheManager redisCacheManager = new RedisCacheManager();
 redisCacheManager.setRedisManager(redisManager());
 redisCacheManager.setKeyPrefix(CACHE_KEY);
 //           session          id    ：  id        ， ->  ：User must has getter for field: xx
 redisCacheManager.setPrincipalIdFieldName("id");
 return redisCacheManager;
 }

 /**
 * SessionID   
 */
 @Bean
 public ShiroSessionIdGenerator sessionIdGenerator(){
 return new ShiroSessionIdGenerator();
 }

 /**
 *   RedisSessionDAO (    shiro-redis    )
 */
 @Bean
 public RedisSessionDAO redisSessionDAO() {
 RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
 redisSessionDAO.setRedisManager(redisManager());
 redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
 redisSessionDAO.setKeyPrefix(SESSION_KEY);
 redisSessionDAO.setExpire(EXPIRE);
 return redisSessionDAO;
 }

 /**
 *   Session   
 */
 @Bean
 public SessionManager sessionManager() {
 ShiroSessionManager shiroSessionManager = new ShiroSessionManager();
 shiroSessionManager.setSessionDAO(redisSessionDAO());
 return shiroSessionManager;
 }

}

3.shiro 동적 로드 권한 처리 방법

loadFilterChainDefinitionMap:권한 초기 화
ex:위의 Shiro 설정 클래스 Shiro Config 의 Shiro 기본 설정 shiro FilterFactory 방법 에서 데이터베이스 에 설 정 된 모든 uri 권한 을 불 러 오고 인터페이스 와 설정 권한 필터 등 을 사용 해 야 합 니 다.
[비고:필터 설정 순 서 를 뒤 바 꿀 수 없습니다.여러 필터 용,분할]
ex: filterChainDefinitionMap.put("/api/system/user/list", "authc,token,zqPerms[user1]")

updatePermission:데이터베이스 에 있 는 uri 권한 을 동적 으로 새로 고침->페이지 는 새로 추 가 된 uri 경 로 를 데이터베이스 에 설정 합 니 다.즉,새로운 권한 을 설정 할 때 이 방법 으로 동적 으로 uri 권한 을 불 러 올 수 있 습 니 다

updatePermission ByRoleId:shiro 동적 권한 로드->지정 한 사용자 권한 을 할당 할 때 이 방법 으로 shiro 캐 시 를 삭제 하고 doGetAuthorizationInfo 방법 으로 권한 을 부여 하 는 역할 과 권한 을 다시 실행 할 수 있 습 니 다

public interface ShiroService {

 /**
 *       ->      
 *
 * @param :
 * @return: java.util.Map<java.lang.String,java.lang.String>
 */
 Map<String, String> loadFilterChainDefinitionMap();

 /**
 *   uri          ，                    uri  
 *
 * @param shiroFilterFactoryBean
 * @param roleId
 * @param isRemoveSession:
 * @return: void
 */
 void updatePermission(ShiroFilterFactoryBean shiroFilterFactoryBean, Integer roleId, Boolean isRemoveSession);

 /**
 * shiro       ->   ：  shiro  ，    doGetAuthorizationInfo         
 *
 * @param roleId
 * @param isRemoveSession:
 * @return: void
 */
 void updatePermissionByRoleId(Integer roleId, Boolean isRemoveSession);

}

@Slf4j
@Service
public class ShiroServiceImpl implements ShiroService {

 @Autowired
 private MenuMapper menuMapper;
 @Autowired
 private UserMapper userMapper;
 @Autowired
 private RoleMapper roleMapper;

 @Override
 public Map<String, String> loadFilterChainDefinitionMap() {
 //     map
 Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
 //     :         ->    start ----------------------------------------------------------
 //   Swagger2  ，      
 filterChainDefinitionMap.put("/swagger-ui.html","anon");
 filterChainDefinitionMap.put("/swagger/**","anon");
 filterChainDefinitionMap.put("/webjars/**", "anon");
 filterChainDefinitionMap.put("/swagger-resources/**","anon");
 filterChainDefinitionMap.put("/v2/**","anon");
 filterChainDefinitionMap.put("/static/**", "anon");

 //   
 filterChainDefinitionMap.put("/api/auth/login/**", "anon");
 //     
 filterChainDefinitionMap.put("/api/auth/loginByQQ", "anon");
 filterChainDefinitionMap.put("/api/auth/afterlogin.do", "anon");
 //   
 filterChainDefinitionMap.put("/api/auth/logout", "anon");
 //        ，     
 filterChainDefinitionMap.put("/api/auth/unauth", "anon");
 // token    
 filterChainDefinitionMap.put("/api/auth/tokenExpired", "anon");
 //     
 filterChainDefinitionMap.put("/api/auth/downline", "anon");
 //    end ----------------------------------------------------------

 //              url resources           
 List<Menu> permissionList = menuMapper.selectList( null );
 if ( !CollectionUtils.isEmpty( permissionList ) ) {
  permissionList.forEach( e -> {
  if ( StringUtils.isNotBlank( e.getUrl() ) ) {
   //   url         ,          
   List<Role> roleList = roleMapper.selectRoleByMenuId( e.getId() );
   StringJoiner zqRoles = new StringJoiner(",", "zqRoles[", "]");
   if ( !CollectionUtils.isEmpty( roleList ) ){
   roleList.forEach( f -> {
    zqRoles.add( f.getCode() );
   });
   }

   //              
   // ①     
   // ②       token    -   token    
   // ③      zqRoles：                    ; roles[admin,guest] :               ，   hasAllRoles()  
   // ④ zqPerms:      url        【 ：       ,   】
//   filterChainDefinitionMap.put( "/api" + e.getUrl(),"authc,token,roles[admin,guest],zqPerms[" + e.getResources() + "]" );
   filterChainDefinitionMap.put( "/api" + e.getUrl(),"authc,token,"+ zqRoles.toString() +",zqPerms[" + e.getResources() + "]" );
//   filterChainDefinitionMap.put("/api/system/user/listPage", "authc,token,zqPerms[user1]"); //        
  }
  });
 }
 // ⑤      【 ：map      key】
 filterChainDefinitionMap.put("/**", "authc");
 return filterChainDefinitionMap;
 }

 @Override
 public void updatePermission(ShiroFilterFactoryBean shiroFilterFactoryBean, Integer roleId, Boolean isRemoveSession) {
 synchronized (this) {
  AbstractShiroFilter shiroFilter;
  try {
  shiroFilter = (AbstractShiroFilter) shiroFilterFactoryBean.getObject();
  } catch (Exception e) {
  throw new MyException("get ShiroFilter from shiroFilterFactoryBean error!");
  }
  PathMatchingFilterChainResolver filterChainResolver = (PathMatchingFilterChainResolver) shiroFilter.getFilterChainResolver();
  DefaultFilterChainManager manager = (DefaultFilterChainManager) filterChainResolver.getFilterChainManager();

  //            
  manager.getFilterChains().clear();
  //           ,       ,         
  //  ps:         ,        map       ,            
  shiroFilterFactoryBean.getFilterChainDefinitionMap().clear();
  //             
  shiroFilterFactoryBean.setFilterChainDefinitionMap(loadFilterChainDefinitionMap());
  //         
  Map<String, String> chains = shiroFilterFactoryBean.getFilterChainDefinitionMap();
  for (Map.Entry<String, String> entry : chains.entrySet()) {
  manager.createChain(entry.getKey(), entry.getValue());
  }
  log.info("---------------     url    ！ ---------------");

  //              shiro  
  if(roleId != null){
  updatePermissionByRoleId(roleId,isRemoveSession);
  }
 }
 }

 @Override
 public void updatePermissionByRoleId(Integer roleId, Boolean isRemoveSession) {
 //          shiro     ->       
 List<User> userList = userMapper.selectUserByRoleId(roleId);
 //                ,               ; isRemoveSession true   Session ->        
 if ( !CollectionUtils.isEmpty( userList ) ) {
  for (User user : userList) {
  ShiroUtils.deleteCache(user.getUsername(), isRemoveSession);
  }
 }
 log.info("---------------           ！ ---------------");
 }

}

4.shiro 에서 사용자 정의 역할,권한 필터
1.사용자 정의 uri 권한 필터 zqPerms

@Slf4j
public class MyPermissionsAuthorizationFilter extends PermissionsAuthorizationFilter {

 @Override
 protected boolean onAccessDenied(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
 HttpServletRequest httpRequest = (HttpServletRequest) request;
 HttpServletResponse httpResponse = (HttpServletResponse) response;
 String requestUrl = httpRequest.getServletPath();
 log.info("   url: " + requestUrl);

 //           
 Subject subject = this.getSubject(request, response);
 if (subject.getPrincipal() == null) {
  this.saveRequestAndRedirectToLogin(request, response);
 } else {
  //    http      
  HttpServletRequest req = (HttpServletRequest) request;
  HttpServletResponse resp = (HttpServletResponse) response;

  //        
  String header = req.getHeader("X-Requested-With");
  // ajax       X-Requested-With: XMLHttpRequest       
  if (header!=null && "XMLHttpRequest".equals(header)){
  resp.setContentType("text/json,charset=UTF-8");
  resp.getWriter().print("{\"success\":false,\"msg\":\"      ！\"}");
  }else { //    
  String unauthorizedUrl = this.getUnauthorizedUrl();
  if (StringUtils.hasText(unauthorizedUrl)) {
   WebUtils.issueRedirect(request, response, unauthorizedUrl);
  } else {
   WebUtils.toHttp(response).sendError(401);
  }
  }

 }
 return false;
 }
 
}

2,사용자 정의 역할 권한 필터 zqRoles
shiro 네 이 티 브 캐릭터 필터 Roles AuthorizationFilter 는 기본적으로 roles[admin,guest]를 동시에 만족 시 켜 야 권한 이 있 으 며,사용자 정의 zqRoles 는 그 중 하나만 만족 시 키 면 접근 할 수 있 습 니 다.
ex: zqRoles[admin,guest]

public class MyRolesAuthorizationFilter extends AuthorizationFilter {

 @Override
 protected boolean isAccessAllowed(ServletRequest req, ServletResponse resp, Object mappedValue) throws Exception {
  Subject subject = getSubject(req, resp);
  String[] rolesArray = (String[]) mappedValue;
  //       ，     
  if (rolesArray == null || rolesArray.length == 0) {
   return true;
  }
  for (int i = 0; i < rolesArray.length; i++) {
   //      rolesArray      ，      
   if (subject.hasRole(rolesArray[i])) {
    return true;
   }
  }
  return false;
 }

}

3.사용자 정의 token 필터 token->token 이 만 료 되 었 는 지 여 부 를 판단 합 니 다.

@Slf4j
public class TokenCheckFilter extends UserFilter {

 /**
  * token  、  
  */
 private static final String TOKEN_EXPIRED_URL = "/api/auth/tokenExpired";

 /**
  *          true:     false:    
  * mappedValue    url      
  * subject.isPermitted            mappedValue  
  */
 @Override
 public boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
  HttpServletRequest httpRequest = (HttpServletRequest) request;
  HttpServletResponse httpResponse = (HttpServletResponse) response;
  //        token
  String token = WebUtils.toHttp(request).getHeader(Constants.REQUEST_HEADER);
  log.info("   token：" + token );
  User userInfo = ShiroUtils.getUserInfo();
  String userToken = userInfo.getToken();
  //   token    
  if ( !token.equals(userToken) ){
   return false;
  }
  return true;
 }

 /**
  *          :        null            ,            
  */
 @Override
 protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
  User userInfo = ShiroUtils.getUserInfo();
  //           -         
  WebUtils.issueRedirect(request, response, TOKEN_EXPIRED_URL);
  return false;
 }

}

5.프로젝트 에 사용 되 는 도구 류,상수 등
따뜻 한 팁:여 기 는 부분 일 뿐 자세 한 내용 은 글 말미 에 제 시 된 사례 demo 소스 코드 를 참고 할 수 있 습 니 다.
1.Shiro 도구 류

public class ShiroUtils {

 /**       **/
 private ShiroUtils(){ }

 private static RedisSessionDAO redisSessionDAO = SpringUtil.getBean(RedisSessionDAO.class);

 /**
  *       Session
  * @Return SysUserEntity     
  */
 public static Session getSession() {
  return SecurityUtils.getSubject().getSession();
 }

 /**
  *     
  */
 public static void logout() {
  SecurityUtils.getSubject().logout();
 }

 /**
  *         
  * @Return SysUserEntity     
  */
 public static User getUserInfo() {
  return (User) SecurityUtils.getSubject().getPrincipal();
 }

 /**
  *         
  * @Param username     
  * @Param isRemoveSession     Session，          
  */
 public static void deleteCache(String username, boolean isRemoveSession){
  //      Session
  Session session = null;
  //           session  
  Collection<Session> sessions = redisSessionDAO.getActiveSessions();
  User sysUserEntity;
  Object attribute = null;
  //   Session,          Session
  for(Session sessionInfo : sessions){
   attribute = sessionInfo.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
   if (attribute == null) {
    continue;
   }
   sysUserEntity = (User) ((SimplePrincipalCollection) attribute).getPrimaryPrincipal();
   if (sysUserEntity == null) {
    continue;
   }
   if (Objects.equals(sysUserEntity.getUsername(), username)) {
    session=sessionInfo;
    //              session，     ->        
    if (isRemoveSession) {
     redisSessionDAO.delete(session);
    }
   }
  }

  if (session == null||attribute == null) {
   return;
  }
  //  session
  if (isRemoveSession) {
   redisSessionDAO.delete(session);
  }
  //  Cache，             
  DefaultWebSecurityManager securityManager = (DefaultWebSecurityManager) SecurityUtils.getSecurityManager();
  Authenticator authc = securityManager.getAuthenticator();
  ((LogoutAware) authc).onLogout((SimplePrincipalCollection) attribute);
 }

 /**
  *             Session
  * @param username
  */
 private static Session getSessionByUsername(String username){
  //           session  
  Collection<Session> sessions = redisSessionDAO.getActiveSessions();
  User user;
  Object attribute;
  //   Session,          Session
  for(Session session : sessions){
   attribute = session.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
   if (attribute == null) {
    continue;
   }
   user = (User) ((SimplePrincipalCollection) attribute).getPrimaryPrincipal();
   if (user == null) {
    continue;
   }
   if (Objects.equals(user.getUsername(), username)) {
    return session;
   }
  }
  return null;
 }

}

2.Redis 상수 류

public interface RedisConstant {
 /**
  * TOKEN  
  */
 String REDIS_PREFIX_LOGIN = "code-generator_token_%s";
}

3.Spring 컨 텍스트 도구 류

@Component
public class SpringUtil implements ApplicationContextAware {
 private static ApplicationContext context;
 /**
  * Spring bean          ApplicationContextAware   
  *      ,setApplicationContext()  ,     ApplicationContext        
  */
 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  context = applicationContext;
 }
 /**
  *   Name     Bean
  */
 public static <T> T getBean(Class<T> beanClass) {
  return context.getBean(beanClass);
 }
}

6.사례 데모 소스 코드
GitHub 주소
https://github.com/zhengqingya/code-generator/tree/master/code-generator-api/src/main/java/com/zhengqing/modules/shiro
코드 클 라 우 드 주소
https://gitee.com/zhengqingya/code-generator/blob/master/code-generator-api/src/main/java/com/zhengqing/modules/shiro
로 컬 다운로드
http://xiazai.jb51.net/201909/yuanma/code-generator(jb51net).rar
총결산
이상 은 제 가 클 라 이언 트 의 실제 IP 를 처리 하 는 방법 입 니 다.본 고의 내용 이 여러분 의 학습 이나 업무 에 어느 정도 참고 학습 가 치 를 가지 기 를 바 랍 니 다.여러분 이 저희 에 대한 지지 에 감 사 드 립 니 다.