2. 程式人生 > >Spring Security 動態url許可權控制（三）

Spring Security 動態url許可權控制（三）

阿新 • • 發佈：2019-10-19

一、前言

本篇文章將講述Spring Security 動態分配url許可權，未登入許可權控制，登入過後根據登入使用者角色授予訪問url許可權

基本環境
  1. spring-boot 2.1.8
  2. mybatis-plus 2.2.0
  3. mysql 資料庫
  4. maven專案
Spring Security入門學習可參考之前文章：
  1. SpringBoot整合Spring Security入門體驗（一）
    https://blog.csdn.net/qq_38225558/article/details/101754743
  2. Spring Security 自定義登入認證（二）
    https://blog.csdn.net/qq_38225558/article/details/102542072

二、資料庫建表

表關係簡介：
  1. 使用者表t_sys_user 關聯 角色表t_sys_role 兩者建立中間關係表t_sys_user_role
  2. 角色表t_sys_role 關聯 許可權表t_sys_permission 兩者建立中間關係表t_sys_role_permission
  3. 最終體現效果為當前登入使用者所具備的角色關聯能訪問的所有url，只要給角色分配相應的url許可權即可

溫馨小提示：這裡邏輯根據個人業務來定義，小編這裡講解案例只給使用者對應的角色分配訪問許可權，像其它的 直接給使用者分配許可權等等可以自己實現

表模擬資料如下：

三、Spring Security 動態許可權控制

1、未登入訪問許可權控制

自定義AdminAuthenticationEntryPoint類實現AuthenticationEntryPoint類

這裡是認證許可權入口 -> 即在未登入的情況下訪問所有介面都會攔截到此（除了放行忽略介面）

溫馨小提示：ResponseUtils和ApiResult是小編這裡模擬前後端分離情況下返回json格式資料所使用工具類，具體實現可參考文末給出的demo原始碼

@Component
public class AdminAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) {
        ResponseUtils.out(response, ApiResult.fail("未登入！！！"));
    }
}

2、自定義過濾器MyAuthenticationFilter繼承OncePerRequestFilter實現訪問鑑權

每次訪問介面都會經過此，我們可以在這裡記錄請求引數、響應內容，或者處理前後端分離情況下，以token換使用者許可權資訊，token是否過期，請求頭型別是否正確，防止非法請求等等

  1. logRequestBody()方法：記錄請求訊息體
  2. logResponseBody()方法：記錄響應訊息體

【注：請求的HttpServletRequest流只能讀一次，下一次就不能讀取了，因此這裡要使用自定義的MultiReadHttpServletRequest工具解決流只能讀一次的問題，響應同理，具體可參考文末demo原始碼實現】

@Slf4j
@Component
public class MyAuthenticationFilter extends OncePerRequestFilter {

    private final UserDetailsServiceImpl userDetailsService;

    protected MyAuthenticationFilter(UserDetailsServiceImpl userDetailsService) {
        this.userDetailsService = userDetailsService;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        System.out.println("請求頭型別： " + request.getContentType());
        if ((request.getContentType() == null && request.getContentLength() > 0) || (request.getContentType() != null && !request.getContentType().contains(Constants.REQUEST_HEADERS_CONTENT_TYPE))) {
            filterChain.doFilter(request, response);
            return;
        }

        MultiReadHttpServletRequest wrappedRequest = new MultiReadHttpServletRequest(request);
        MultiReadHttpServletResponse wrappedResponse = new MultiReadHttpServletResponse(response);
        StopWatch stopWatch = new StopWatch();
        try {
            stopWatch.start();
            // 記錄請求的訊息體
            logRequestBody(wrappedRequest);

//            String token = "123";
            // 前後端分離情況下，前端登入後將token儲存在cookie中，每次訪問介面時通過token去拿使用者許可權
            String token = wrappedRequest.getHeader(Constants.REQUEST_HEADER);
            log.debug("後臺檢查令牌:{}", token);
            if (StringUtils.isNotBlank(token)) {
                // 檢查token
                SecurityUser securityUser = userDetailsService.getUserByToken(token);
                if (securityUser == null || securityUser.getCurrentUserInfo() == null) {
                    throw new AccessDeniedException("TOKEN已過期，請重新登入！");
                }
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(securityUser, null, securityUser.getAuthorities());
                // 全域性注入角色許可權資訊和登入使用者基本資訊
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
            filterChain.doFilter(wrappedRequest, wrappedResponse);
        } finally {
            stopWatch.stop();
            long usedTimes = stopWatch.getTotalTimeMillis();
            // 記錄響應的訊息體
            logResponseBody(wrappedRequest, wrappedResponse, usedTimes);
        }

    }

    private String logRequestBody(MultiReadHttpServletRequest request) {
        MultiReadHttpServletRequest wrapper = request;
        if (wrapper != null) {
            try {
                String bodyJson = wrapper.getBodyJsonStrByJson(request);
                String url = wrapper.getRequestURI().replace("//", "/");
                System.out.println("-------------------------------- 請求url: " + url + " --------------------------------");
                Constants.URL_MAPPING_MAP.put(url, url);
                log.info("`{}` 接收到的引數: {}",url , bodyJson);
                return bodyJson;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private void logResponseBody(MultiReadHttpServletRequest request, MultiReadHttpServletResponse response, long useTime) {
        MultiReadHttpServletResponse wrapper = response;
        if (wrapper != null) {
            byte[] buf = wrapper.getBody();
            if (buf.length > 0) {
                String payload;
                try {
                    payload = new String(buf, 0, buf.length, wrapper.getCharacterEncoding());
                } catch (UnsupportedEncodingException ex) {
                    payload = "[unknown]";
                }
                log.info("`{}`  耗時:{}ms  返回的引數: {}", Constants.URL_MAPPING_MAP.get(request.getRequestURI()), useTime, payload);
            }
        }
    }

}

3、自定義UserDetailsServiceImpl實現UserDetailsService 和 自定義SecurityUser實現UserDetails 認證使用者詳情

這個在上一篇文章中也提及過，但上次未做角色許可權處理，這次我們來一起加上吧

@Service("userDetailsService")
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private RoleMapper roleMapper;
    @Autowired
    private UserRoleMapper userRoleMapper;

    /***
     * 根據賬號獲取使用者資訊
     * @param username:
     * @return: org.springframework.security.core.userdetails.UserDetails
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 從資料庫中取出使用者資訊
        List<User> userList = userMapper.selectList(new EntityWrapper<User>().eq("username", username));
        User user;
        // 判斷使用者是否存在
        if (!CollectionUtils.isEmpty(userList)) {
            user = userList.get(0);
        } else {
            throw new UsernameNotFoundException("使用者名稱不存在！");
        }
        // 返回UserDetails實現類
        return new SecurityUser(user, getUserRoles(user.getId()));
    }

    /***
     * 根據token獲取使用者許可權與基本資訊
     *
     * @param token:
     * @return: com.zhengqing.config.security.dto.SecurityUser
     */
    public SecurityUser getUserByToken(String token) {
        User user = null;
        List<User> loginList = userMapper.selectList(new EntityWrapper<User>().eq("token", token));
        if (!CollectionUtils.isEmpty(loginList)) {
            user = loginList.get(0);
        }
        return user != null ? new SecurityUser(user, getUserRoles(user.getId())) : null;
    }

    /**
     * 根據使用者id獲取角色許可權資訊
     *
     * @param userId
     * @return
     */
    private List<Role> getUserRoles(Integer userId) {
        List<UserRole> userRoles = userRoleMapper.selectList(new EntityWrapper<UserRole>().eq("user_id", userId));
        List<Role> roleList = new LinkedList<>();
        for (UserRole userRole : userRoles) {
            Role role = roleMapper.selectById(userRole.getRoleId());
            roleList.add(role);
        }
        return roleList;
    }

}

這裡再說下自定義SecurityUser是因為Spring Security自帶的 UserDetails （儲存當前使用者基本資訊） 有時候可能不滿足我們的需求，因此我們可以自己定義一個來擴充套件我們的需求

getAuthorities()方法：即授予當前使用者角色許可權資訊

@Data
@Slf4j
public class SecurityUser implements UserDetails {
    /**
     * 當前登入使用者
     */
    private transient User currentUserInfo;
    /**
     * 角色
     */
    private transient List<Role> roleList;

    public SecurityUser() { }

    public SecurityUser(User user) {
        if (user != null) {
            this.currentUserInfo = user;
        }
    }

    public SecurityUser(User user, List<Role> roleList) {
        if (user != null) {
            this.currentUserInfo = user;
            this.roleList = roleList;
        }
    }

    /**
     * 獲取當前使用者所具有的角色
     *
     * @return
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        if (!CollectionUtils.isEmpty(this.roleList)) {
            for (Role role : this.roleList) {
                SimpleGrantedAuthority authority = new SimpleGrantedAuthority(role.getCode());
                authorities.add(authority);
            }
        }
        return authorities;
    }

    @Override
    public String getPassword() {
        return currentUserInfo.getPassword();
    }

    @Override
    public String getUsername() {
        return currentUserInfo.getUsername();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

4、自定義UrlFilterInvocationSecurityMetadataSource實現FilterInvocationSecurityMetadataSource重寫getAttributes()方法 獲取訪問該url所需要的角色許可權資訊

執行完之後到 下一步 UrlAccessDecisionManager 中認證許可權

@Component
public class UrlFilterInvocationSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {

    @Autowired
    PermissionMapper permissionMapper;
    @Autowired
    RolePermissionMapper rolePermissionMapper;
    @Autowired
    RoleMapper roleMapper;

    /***
     * 返回該url所需要的使用者許可權資訊
     *
     * @param object: 儲存請求url資訊
     * @return: null：標識不需要任何許可權都可以訪問
     */
    @Override
    public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
        // 獲取當前請求url
        String requestUrl = ((FilterInvocation) object).getRequestUrl();
        // TODO 忽略url請放在此處進行過濾放行
        if ("/login".equals(requestUrl) || requestUrl.contains("logout")) {
            return null;
        }

        // 資料庫中所有url
        List<Permission> permissionList = permissionMapper.selectList(null);
        for (Permission permission : permissionList) {
            // 獲取該url所對應的許可權
            if (requestUrl.equals(permission.getUrl())) {
                List<RoleMenu> permissions = rolePermissionMapper.selectList(new EntityWrapper<RoleMenu>().eq("permission_id", permission.getId()));
                List<String> roles = new LinkedList<>();
                if (!CollectionUtils.isEmpty(permissions)){
                    Integer roleId = permissions.get(0).getRoleId();
                    Role role = roleMapper.selectById(roleId);
                    roles.add(role.getCode());
                }
                // 儲存該url對應角色許可權資訊
                return SecurityConfig.createList(roles.toArray(new String[roles.size()]));
            }
        }
        // 如果資料中沒有找到相應url資源則為非法訪問，要求使用者登入再進行操作
        return SecurityConfig.createList(Constants.ROLE_LOGIN);
    }

    @Override
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return FilterInvocation.class.isAssignableFrom(aClass);
    }
}

5、自定義UrlAccessDecisionManager實現AccessDecisionManager重寫decide()方法 對訪問url進行許可權認證處理

此處小編的處理邏輯是隻要包含其中一個角色即可訪問

@Component
public class UrlAccessDecisionManager implements AccessDecisionManager {

    /**
     * @param authentication: 當前登入使用者的角色資訊
     * @param object: 請求url資訊
     * @param collection: `UrlFilterInvocationSecurityMetadataSource`中的getAttributes方法傳來的，表示當前請求需要的角色（可能有多個）
     * @return: void
     */
    @Override
    public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> collection) throws AccessDeniedException, AuthenticationException {
        // 遍歷角色
        for (ConfigAttribute ca : collection) {
            // ① 當前url請求需要的許可權
            String needRole = ca.getAttribute();
            if (Constants.ROLE_LOGIN.equals(needRole)) {
                if (authentication instanceof AnonymousAuthenticationToken) {
                    throw new BadCredentialsException("未登入!");
                } else {
                    throw new AccessDeniedException("未授權該url！");
                }
            }

            // ② 當前使用者所具有的角色
            Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
            for (GrantedAuthority authority : authorities) {
                // 只要包含其中一個角色即可訪問
                if (authority.getAuthority().equals(needRole)) {
                    return;
                }
            }
        }
        throw new AccessDeniedException("請聯絡管理員分配許可權！");
    }

    @Override
    public boolean supports(ConfigAttribute configAttribute) {
        return true;
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}

6、自定義無許可權處理器 UrlAccessDeniedHandler實現AccessDeniedHandler重寫handle()方法

在這裡自定義403無許可權響應內容，登入過後的許可權處理
【 注：要和未登入時的許可權處理區分開哦~ 】

@Component
public class UrlAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
        ResponseUtils.out(response, ApiResult.fail(403, e.getMessage()));
    }
}

7、最後在Security 核心配置類中配置以上處理

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 訪問鑑權 - 認證token、簽名...
     */
    private final MyAuthenticationFilter myAuthenticationFilter;
    /**
     * 訪問許可權認證異常處理
     */
    private final AdminAuthenticationEntryPoint adminAuthenticationEntryPoint;
    /**
     * 使用者密碼校驗過濾器
     */
    private final AdminAuthenticationProcessingFilter adminAuthenticationProcessingFilter;

    // 上面是登入認證相關  下面為url許可權相關 - ========================================================================================

    /**
     * 獲取訪問url所需要的角色資訊
     */
    private final UrlFilterInvocationSecurityMetadataSource urlFilterInvocationSecurityMetadataSource;
    /**
     * 認證許可權處理 - 將上面所獲得角色許可權與當前登入使用者的角色做對比，如果包含其中一個角色即可正常訪問
     */
    private final UrlAccessDecisionManager urlAccessDecisionManager;
    /**
     * 自定義訪問無許可權介面時403響應內容
     */
    private final UrlAccessDeniedHandler urlAccessDeniedHandler;

    public SecurityConfig(MyAuthenticationFilter myAuthenticationFilter, AdminAuthenticationEntryPoint adminAuthenticationEntryPoint, AdminAuthenticationProcessingFilter adminAuthenticationProcessingFilter, UrlFilterInvocationSecurityMetadataSource urlFilterInvocationSecurityMetadataSource, UrlAccessDeniedHandler urlAccessDeniedHandler, UrlAccessDecisionManager urlAccessDecisionManager) {
        this.myAuthenticationFilter = myAuthenticationFilter;
        this.adminAuthenticationEntryPoint = adminAuthenticationEntryPoint;
        this.adminAuthenticationProcessingFilter = adminAuthenticationProcessingFilter;
        this.urlFilterInvocationSecurityMetadataSource = urlFilterInvocationSecurityMetadataSource;
        this.urlAccessDeniedHandler = urlAccessDeniedHandler;
        this.urlAccessDecisionManager = urlAccessDecisionManager;
    }


    /**
     * 許可權配置
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = http.antMatcher("/**").authorizeRequests();

        // 禁用CSRF 開啟跨域
        http.csrf().disable().cors();

        // 未登入認證異常
        http.exceptionHandling().authenticationEntryPoint(adminAuthenticationEntryPoint);
        // 登入過後訪問無許可權的介面時自定義403響應內容
        http.exceptionHandling().accessDeniedHandler(urlAccessDeniedHandler);

        // url許可權認證處理
        registry.withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
            @Override
            public <O extends FilterSecurityInterceptor> O postProcess(O o) {
                o.setSecurityMetadataSource(urlFilterInvocationSecurityMetadataSource);
                o.setAccessDecisionManager(urlAccessDecisionManager);
                return o;
            }
        });

        // 不建立會話 - 即通過前端傳token到後臺過濾器中驗證是否存在訪問許可權
//        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

        // 標識訪問 `/home` 這個介面，需要具備`ADMIN`角色
//        registry.antMatchers("/home").hasRole("ADMIN");
        // 標識只能在 伺服器本地ip[127.0.0.1或localhost] 訪問 `/home` 這個介面，其他ip地址無法訪問
        registry.antMatchers("/home").hasIpAddress("127.0.0.1");
        // 允許匿名的url - 可理解為放行介面 - 多個介面使用,分割
        registry.antMatchers("/login", "/index").permitAll();
//        registry.antMatchers("/**").access("hasAuthority('admin')");
        // OPTIONS(選項)：查詢適用於一個特定網址資源的通訊選擇。 在不需執行具體的涉及資料傳輸的動作情況下， 允許客戶端來確定與資源相關的選項以及 / 或者要求， 或是一個伺服器的效能
        registry.antMatchers(HttpMethod.OPTIONS, "/**").denyAll();
        // 自動登入 - cookie儲存方式
        registry.and().rememberMe();
        // 其餘所有請求都需要認證
        registry.anyRequest().authenticated();
        // 防止iframe 造成跨域
        registry.and().headers().frameOptions().disable();

        // 自定義過濾器在登入時認證使用者名稱、密碼
        http.addFilterAt(adminAuthenticationProcessingFilter, UsernamePasswordAuthenticationFilter.class)
            .addFilterBefore(myAuthenticationFilter, BasicAuthenticationFilter.class);
    }

    /**
     * 忽略攔截url或靜態資原始檔夾 - web.ignoring(): 會直接過濾該url - 將不會經過Spring Security過濾器鏈
     *                             http.permitAll(): 不會繞開springsecurity驗證，相當於是允許該路徑通過
     * @param web
     * @throws Exception
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers(HttpMethod.GET,
                "/favicon.ico",
                "/*.html",
                "/**/*.css",
                "/**/*.js");
    }

}

四、編寫測試程式碼

控制層：

@Slf4j
@RestController
public class IndexController {

    @GetMapping("/")
    public ModelAndView showHome() {
        return new ModelAndView("home.html");
    }

    @GetMapping("/index")
    public String index() {
        return "Hello World ~";
    }

    @GetMapping("/login")
    public ModelAndView login() {
        return new ModelAndView("login.html");
    }

    @GetMapping("/home")
    public String home() {
        String name = SecurityContextHolder.getContext().getAuthentication().getName();
        log.info("登陸人：" + name);
        return "Hello~ " + name;
    }

    @GetMapping(value ="/admin")
    // 訪問路徑`/admin` 具有`ADMIN`角色許可權   【這種是寫死方式】
//    @PreAuthorize("hasPermission('/admin','ADMIN')")
    public String admin() {
        return "Hello~ 管理員";
    }

    @GetMapping("/test")
    public String test() {
        return "Hello~ 測試許可權訪問介面";
    }
    
}

頁面和其它相關程式碼這裡就不貼出來了，具體可參考文末demo原始碼

五、執行訪問測試效果

1、未登入時

2、登入過後如果有許可權則正常訪問

3、登入過後，沒有許可權

這裡我們可以修改資料庫角色許可權關聯表t_sys_role_permission來進行測試哦 ~

Security 動態url許可權也就是依賴這張表來判斷的，只要修改這張表分配角色對應url許可權資源，使用者訪問url時就會動態的去判斷，無需做其他處理，如果是將許可權資訊放在了快取中，修改表資料時及時更新快取即可！

4、登入過後，訪問資料庫中沒有配置的url 並且 在Security中沒有忽略攔截的url時

六、總結

  1. 自定義未登入許可權處理器AdminAuthenticationEntryPoint - 自定義未登入時訪問無許可權url響應內容
  2. 自定義訪問鑑權過濾器MyAuthenticationFilter - 記錄請求響應日誌、是否合法訪問，驗證token過期等
  3. 自定義UrlFilterInvocationSecurityMetadataSource - 獲取訪問該url所需要的角色許可權
  4. 自定義UrlAccessDecisionManager - 對訪問url進行許可權認證處理
  5. 自定義UrlAccessDeniedHandler - 登入過後訪問無許可權url失敗處理器 - 自定義403無許可權響應內容
  6. 在Security核心配置類中配置以上處理器和過濾器
Security動態許可權相關程式碼：

本文案例demo原始碼

https://gitee.com/zhengqingya/java-worksp

相關推薦

Spring Security 動態url許可權控制（三）

一、前言 本篇文章將講述Spring Security 動態分配url許可權，未登入許可權控制，登入過後根據登入使用者角色授予訪問url許可權 基本環境 spring-boot 2.1.8 mybatis-plus 2.2.0 mysql 資料庫 maven專案 Spring Security入門學習可參

springboot使用Spring Security+OAuth2做許可權控制

文章來源：http://lxgandlz.cn/404.html     前面有一篇文章Spring+Spring Security+OAuth2實現REST API許可權控制，講了Spring+Spring Security+OAuth2來實現REST API許可權

使用Spring Security進行使用者許可權控制

系統比較簡單,所以只有使用者表, 角色表和域表, 沒有許可權表. 各個域的使用者是隔離的, 因為前後端分離, 控制起來格外不方便, 不過好歹是用filter實現了,bug還很多改天再說. 現在的問題就是登入 ,前端獲取登入使用者以及許可權攔截 .其中比較花時間的是使用者登入

淺談spring security中的許可權控制

當我們在OAuth登陸後，獲取了登陸的令牌，使用該令牌，我們就有了訪問一些受OAuth保護的介面的能力。具體可以看本人的這兩篇部落

別再讓你的微服務裸奔了，基於 Spring Session & Spring Security 微服務許可權控制

微服務架構 閘道器：路由使用者請求到指定服務，轉發前端 Cookie 中包含的 Session 資訊； 使用者服務：使用者登入認證（Authentication），使用者授權（Authority），使用者管理（Redis Session Management） 其他服務：依賴 Redis 中使用者資

spring boot 登錄註冊 demo （三） -- 前後端傳遞

lin 表單提交 www col log ref rec put 內容 前端頁面通過thymeleaf渲染 　　　　<dependency> <groupId>org.springframework.boot</gro

Spring IOC容器的初始化-（三）BeanDefinition的註冊

store erro pan customize 註冊 failed mono def override ---恢復內容開始--- 前言 在上一篇中有一處代碼是BeanDefiniton註冊的入口，我們回顧一下。 1.BeanDefiniton在IOC容器註冊 首先我

*使用Centos下的iptables實現實驗室按教室、按時間進行上網控制（三）

Linux 高校運維 iptables 上網時間控制 本章介紹如何使用time模塊對教室上網進行控制，以206教室為例，206教室網絡屬於Vlan206，net：10.1.26.0/24，gateway:10.1.26.254 206文件； #ALL#iptables -A FORWARD

【轉】Spring Boot幹貨系列：（三）啟動原理解析

無法 time exp 記得 started 打印 ping 正文 exclude 前言 前面幾章我們見識了SpringBoot為我們做的自動配置，確實方便快捷，但是對於新手來說，如果不大懂SpringBoot內部啟動原理，以後難免會吃虧。所以這次博主就跟你們一起一步步揭開

Spring整合Struts2和Hibernate+Maven（三）之請求的處理

關於請求的處理，即涉及前面提到Struts2。 具體流程：頁面發出請求->攔截action->處理action->具體到那個類的哪個方法處理。 頁面發出請求: fm.action="/Login_register"; fm.subm

【NOJ1084】【演算法實驗四】【DP_動態規劃】花生米（三）

1084.花生米（三） 時限：1000ms 記憶體限制：10000K  總時限：3000ms 描述 五一長假第三天，Tom和Jerry在倉庫散步的時候又發現了一堆花生米（倉庫，又見倉庫……）。這次Tom制定分花生米規則如下：  ???????1、Tom和Je

Spring Boot + Spring Cloud 構建微服務系統（三）：服務消費和負載（Feign）

Spring Cloud Feign Spring Cloud Feign是一套基於Netflix Feign實現的宣告式服務呼叫客戶端。它使得編寫Web服務客戶端變得更加簡單。我們只需要通過建立介面並用註解來配置它既可完成對Web服務介面的繫結。它具備可插拔的註解支援，包括Feign註解、JAX-RS註解

RabbitMQ使用者角色及許可權控制（轉）

轉載至：https://blog.csdn.net/awhip9/article/details/72123257 2017年05月15日 10:39:26 awhip9 閱讀數：3538  

Spring Boot中使用WebSocket總結（三）：使用訊息佇列實現分散式WebSocket

在上一篇文章（www.zifangsky.cn/1359.html）中我介紹了服務端如何給指定使用者的客戶端傳送訊息，並如何處理對方不線上的情況。在這篇文章中我們繼續思考另外一個重要的問題，那就是：如果我們的專案是分散式環境，登入的使用者被Nginx的反向代理分配到多個不同伺服器，那麼在其中一個伺服器建立了W

Apache Shiro 許可權控制（2）

Shiro的 /WEB-INF目錄下的shiro.ini 配置檔案url匹配方式： ① ？ 可以匹配一個字元   /admin?   ---->可以匹配到/admin1   /admin12匹配不到 ② * 

Apache Shiro Web許可權控制（1）

Shiro官方文件：http://shiro.apache.org/web.html#Web-configuration ①建立一個maven web工程 ②新增依賴 <dependencies> <dependency> <groupId&g

Quartz學習——Spring和Quartz整合詳解（三）

Spring是一個很優秀的框架，它無縫的集成了Quartz，簡單方便的讓企業級應用更好的使用Quartz進行任務的排程。下面就對Spring整合Quartz進行簡單的介紹和示例講解！和上一節 Quartz學習——2、簡單入門示例Demo 的流程相似，介紹Spring和Quar

反射包 java.lang.reflect⑦ 之 Java 中 Proxy 動態代理類 探祕（三）

這個系列好久沒有續作了，你以為完了，錯了。這個動態代理有說不完的知識點，我也是在不斷的學習中才瞭解得到更多的知識。但無可否認的一點是它需更多其他的知識的支援，比如設計模式，設計思想。工作越久越覺得設計模式這個東西的重要性。  其實動態代理的前兩個例子只是簡單的列出了它的一個

spring原始碼學習筆記-初始化（三）-BeanFactory

轉自http://www.sandzhang.com/blog/2011/04/05/spring-study-notes-initialization-3/ refresh()方法中在上篇obtainFreshBeanFactory()方法建立了beanfactory物

C動態記憶體分配：（三）malloc/calloc/realloc/free使用注意事項

10、對於realloc不要將返回結果再賦值給原指標，即ptr=realloc(ptr,new_size)是不建議使用的，因為如果記憶體分配失敗，ptr會變為NULL，如果之前沒有將ptr所在地址賦給其他值的話，會發生無法訪問舊記憶體空間的情況，所以建議使用temp=realloc(ptr,new_size)