暢購商城(十)：購物車-有解無憂

好好學習，天天向上

本文已收錄至我的Github倉庫DayDayUP：github.com/RobodLee/DayDayUP，歡迎Star，更多文章請前往：目錄導航

暢購商城(一)：環境搭建
暢購商城(二)：分布式檔案系統FastDFS
暢購商城(三)：商品管理
暢購商城(四)：Lua、OpenResty、Canal實作廣告快取與同步
暢購商城(五)：Elasticsearch實作商品搜索
暢購商城(六)：商品搜索
暢購商城(七)：Thymeleaf實作靜態頁
暢購商城(八)：微服務網關和JWT令牌
暢購商城(九)：Spring Security Oauth2
暢購商城(十)：購物車

OAuth2.0對接用戶微服務

上一篇文章中提到過，訪問資源服務的時候，需要攜帶令牌去進行權限校驗，那么用戶微服務也是資源服務，所以需要對其進行配置，首先添加OAuth2.0的依賴，

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>

然后把之前匯出的public.key放到用戶微服務的resources目錄下，最后添加一個配置類即可，配置類上需要添加@EnableResourceServer注解，然后繼承自ResourceServerConfigurerAdapter，

@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)//激活方法上的PreAuthorize注解
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    private static final String PUBLIC_KEY = "public.key";//公鑰

    /***
     * 定義JwtTokenStore
     * @param jwtAccessTokenConverter
     * @return
     */
    @Bean
    public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
        return new JwtTokenStore(jwtAccessTokenConverter);
    }

    /***
     * 定義JJwtAccessTokenConverter
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setVerifierKey(getPublicKey());
        return converter;
    }
    /**
     * 獲取非對稱加密公鑰 Key
     * @return 公鑰 Key
     */
    private String getPublicKey() {
        Resource resource = new ClassPathResource(PUBLIC_KEY);
        try {
            InputStreamReader inputStreamReader = new InputStreamReader(resource.getInputStream());
            BufferedReader br = new BufferedReader(inputStreamReader);
            return br.lines().collect(Collectors.joining("\n"));
        } catch (IOException ioe) {
            return null;
        }
    }

    /***
     * Http安全配置，對每個到達系統的http請求鏈接進行校驗
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        //所有請求必須認證通過
        http.authorizeRequests()
                //下邊的路徑放行
                .antMatchers("/user/add,user/load/*").permitAll() //配置 /user/add /user/load/*不需要權限
                .anyRequest().authenticated();    //其他地址需要認證授權
    }

}

這樣配置類就配置好了，在添加了@EnableGlobalMethodSecurity注解后，就可以在指定的方法上面添加注解來進行權限控制，

比如：

@PreAuthorize("hasAnyAuthority('admin')")	//表示該方法只有admin才能訪問
@PutMapping(value = https://www.cnblogs.com/robod/p/"/{id}")
public Result update(@RequestBody User user, @PathVariable String id) {
………………

這樣用戶微服務就配置好了，

網關配置

訪問微服務的JWT令牌是放在請求頭中一個叫“Authorization”的引數中，以“bearer”開頭，因為請求是通過網關轉發給相應的微服務，所以可以對網關進行配置，之前在網關微服務中寫了一個過濾器叫AuthorizeFilter，里面的filter()方法寫的是分別從請求頭、引數、Cookie中獲取token資訊，然后進行校驗，現在稍微修改一下，現在不校驗了，只判斷有無token資訊并進行簡單處理，

還有一點就是有些請求比如登錄注冊等不需要token的就直接放行，

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
	…………
	if (needlessToken(request.getURI().toString())) {
		return chain.filter(exchange);	//如果是不需要token的請求就直接放行
    }
    //還是沒有Token就攔截
    if (StringUtils.isEmpty(token)){
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        return response.setComplete();
    } else {
        if (!hasTokenInHeader) {
            if (!(token.startsWith("brarer ") || token.startsWith("Bearer "))) {
                token = "Bearer " + token;
            }
            request.mutate().header("Authorization",token);
        }
    }
    //Token不為空就校驗Token
    // try {
    //     JwtUtil.parseJWT(token);
    // } catch (Exception e) {
    //     //報例外說明Token是錯誤的，攔截
    //     response.setStatusCode(HttpStatus.UNAUTHORIZED);
    //     return response.setComplete();
    // }
    return chain.filter(exchange);
}

//判斷指定的uri是否不需要token就可以訪問，true表示不需要
public boolean needlessToken(String uri) {
    String[] uris = new String[]{
            "/api/user/add",
            "/api/user/login"
    };
    for (String s : uris) {
        if (s.equals(uri)) {
            return true;
        }
    }
    return false;
}

代碼的意思就是如果請求頭中有token的資訊就不去管它，如果token在引數或者Cookie中，就看是不是以“**Bearer **”開頭，不是的話就添加“Bearer ”，然后存入請求頭中，如果是指定的不需要token的請求就直接放行，為什么現在不校驗呢？因為校驗的作業交給對應的微服務去處理了，網關不負責，

OAuth2.0從資料庫加載資料

在之前的配置中，客戶端的資訊是配置在記憶體中的，用戶也是在記憶體中指定的，現在來改造一下，從資料庫中加載資料，首先是客戶端資訊，修改AuthorizationServerConfig中的configure()方法，

// 客戶端資訊配置
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.jdbc(dataSource).clients(clientDetails());
}
//客戶端配置
@Bean
public ClientDetailsService clientDetails() {
    return new JdbcClientDetailsService(dataSource);
}

我們給客戶端配置了一個JdbcClientDetailsService，

然后就可以從oauth_client_details中加載資料了，

咦？好像沒有在任何地方指定這張表呀，怎么就能從這張表里面加載資料？？？前面不是配了個JdbcClientDetailsService么，點進去看看

哦~ 原來是在JdbcClientDetailsService的內部指定好了呀，

現在就是從資料庫中加載了客戶端的資訊，那怎么加載用戶的資訊呢？這里使用Feign介面去呼叫用戶微服務查詢出用戶的資訊，

//用戶微服務中的UserController
@GetMapping({"/{id}","/load/{id}"})
public Result<User> findById(@PathVariable String id) {
    //呼叫UserService實作根據主鍵查詢User
    User user = userService.findById(id);
    return new Result<User>(true, StatusCode.OK, "查詢成功", user);
}

我們給這個方法配置一個“load/{id}”的路徑，之前已經配置過這個路徑放行了，

然后在用戶的api微服務中添加一個Feign介面，

@FeignClient("user")
@RequestMapping("/user")
public interface UserFeign {

    //根據ID查詢User資料
    @GetMapping({"/load/{id}"})
    Result<User> findById(@PathVariable String id);

}

這樣在認證微服務的UserDetailsServiceImpl的loadUserByUsername()方法中就可以呼叫Feign去資料庫中查詢用戶資訊了，

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    /*客戶端資訊認證*/
    //取出身份，如果身份為空說明沒有認證
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    //沒有認證統一采用httpbasic認證，httpbasic中存盤了client_id和client_secret，開始認證client_id和client_secret
    if(authentication==null){
        ClientDetails clientDetails = clientDetailsService.loadClientByClientId(username);
        if(clientDetails!=null){
            //秘鑰
            String clientSecret = clientDetails.getClientSecret();
            //資料庫查找方式
            return new User(username,clientSecret, AuthorityUtils.commaSeparatedStringToAuthorityList(""));
        }
    }

    /*用戶資訊認證*/
    if (StringUtils.isEmpty(username)) {
        return null;
    }
    com.robod.user.pojo.User user = userFeign.findById(username).getData();	//查詢用戶
    if (user == null ) {
        return null;
    }
    //根據用戶名查詢用戶資訊
    String pwd = user.getPassword();
    //創建User物件
    String permissions = "goods_list,seckill_list";
    UserJwt userDetails = new UserJwt(username,pwd,
                                       AuthorityUtils.commaSeparatedStringToAuthorityList(permissions));
    return userDetails;
}

這樣就OK了，來測驗一下，

這個robod用戶是保存在資料庫中的，可以正常登錄，說明我們的配置是沒有問題的，

微服務之間的令牌傳遞

在實作購物車功能之前，要先明確一個問題，只有登錄過的用戶才可以訪問自己的購物車，所以我們在訪問微服務的時候必須要攜帶令牌，但是還涉及到微服務之間的Feign介面呼叫，令牌該怎么傳遞過去呢？令牌不是放在名為“Authorization”的請求頭中嗎，所以加一個過濾器在Feign呼叫前呼叫，將當前請求的請求頭資訊封裝到Feign請求的請求頭中，但是呢，這個過濾器是很多微服務共用的，所以可以將這個過濾器放在common工程中，哪個微服務需要就直接注入到Spring容器中，

public class FeignHeaderInterceptor implements RequestInterceptor {

    //Feign呼叫前呼叫
    @Override
    public void apply(RequestTemplate template) {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (requestAttributes != null) {
            HttpServletRequest request = requestAttributes.getRequest();
            Enumeration<String> headerNames = request.getHeaderNames();//所有請求頭的名字集合
            if (headerNames != null) {
                while (headerNames.hasMoreElements()) {
                    String headerName = headerNames.nextElement();
                    String headerValue = https://www.cnblogs.com/robod/p/request.getHeader(headerName);
                    template.header(headerName,headerValue);
                }
            }
        }
    }
}

如果哪個微服務想要呼叫的話，就直接在啟動類中注入即可，

@Bean
public FeignHeaderInterceptor feignHeaderInterceptor() {
    return new FeignHeaderInterceptor();
}

這樣就可以實作令牌在不同微服務之間的傳遞，

購物車

現在就可以來實作購物車的功能了，因為購物車畢竟是用來下單的，所以就將購物車功能寫在訂單微服務中，創建一個訂單微服務changgou-service-order以及一個訂單的api工程changgou-service-order-api，

從令牌中獲取用戶名

添加到購物車的流程就是用戶從前端將商品的id和數量以及令牌傳過來，然后決議令牌，拿到用戶名，然后拿著商品的id用Feign呼叫Goods微服務將Sku和Spu查詢出來，然后封裝成一個OrderItem物件，存入Reids中，這個時候Feign介面的呼叫就涉及到微服務之間的令牌傳遞問題了，把FeignHeaderInterceptor注入即可，

這里還有一個問題，就是令牌決議，很簡單，使用公鑰決議即可，封裝一個工具類com.robod.order.utils.TokenDecodeUtil

@Component
public class TokenDecodeUtil {

    //公鑰路徑
    private static final String PUBLIC_KEY_PATH = "public.key";

    //公鑰的內容
    private static String publicKey="";

    /***
     * 獲取用戶資訊
     * @return
     */
    public Map<String,String> getUserInfo() {
        //獲取授權資訊
        OAuth2AuthenticationDetails authentication = 
            (OAuth2AuthenticationDetails) SecurityContextHolder.getContext().getAuthentication().getDetails();
        //令牌解碼
        return decodeToken(authentication.getTokenValue());
    }

    /***
     * 讀取令牌資料
     */
    public Map<String,String> decodeToken(String token){
        //校驗Jwt
        Jwt jwt = JwtHelper.decodeAndVerify(token, new RsaVerifier(getPubKey()));

        //獲取Jwt原始內容
        String claims = jwt.getClaims();
        return JSON.parseObject(claims,Map.class);
    }

    /**
     * 獲取非對稱加密公鑰 Key
     * @return 公鑰 Key
     */
    public String getPubKey() {
        if(!StringUtils.isEmpty(publicKey)){
            return publicKey;
        }
        Resource resource = new ClassPathResource(PUBLIC_KEY_PATH);
        try {
            InputStreamReader inputStreamReader = new InputStreamReader(resource.getInputStream());
            BufferedReader br = new BufferedReader(inputStreamReader);
            publicKey = br.lines().collect(Collectors.joining("\n"));
            return publicKey;
        } catch (IOException ioe) {
            return null;
        }

    }

}

準備作業做好以后就可以撰寫相應的邏輯了，

添加到購物車

//     CartController
@GetMapping("/add")
public Result add(long id,int num) {
    String username = tokenDecodeUtil.getUserInfo().get("username");
    cartService.add(id,num,username);
    return new Result(true, StatusCode.OK,"成功添加到購物車");
}
//-----------------------------------------------------------------------
//     CartServiceImpl
@Override
public void add(long id, int num, String username) {
    BoundHashOperations boundHashOperations = redisTemplate.boundHashOps("Cart_" + username);
    if (num <= 0){
        boundHashOperations.delete(id);
        Long size = boundHashOperations.size();
        if (size == null || size<=0) {
            redisTemplate.delete("Cart_" + username);
        }
        return;
    }
    Sku sku = skuFeign.findById(id).getData();
    if (sku == null) {
        throw new RuntimeException("未查詢到商品資訊");
    }
    Spu spu = spuFeign.findById(sku.getSpuId()).getData();
    if (spu == null) {
        throw new RuntimeException("資料庫中資料例外");
    }
    OrderItem orderItem = createOrderItem(spu,sku,num);
    boundHashOperations.put(id,orderItem);
}

private OrderItem createOrderItem(Spu spu,Sku sku,int num) {
    OrderItem orderItem = new OrderItem();
    orderItem.setCategoryId1(spu.getCategory1Id());
    orderItem.setCategoryId2(spu.getCategory2Id());
    orderItem.setCategoryId3(spu.getCategory3Id());
    orderItem.setSpuId(spu.getId());
    orderItem.setSkuId(sku.getId());
    orderItem.setName(sku.getName());
    orderItem.setNum(num);
    orderItem.setPrice(sku.getPrice());
    orderItem.setMoney(num * sku.getPrice());
    orderItem.setImage(spu.getImage());
    return orderItem;
}

但是現在訪問的話還存在問題，FeignHeaderInterceptor里面ServletRequestAttributes的資料

這是因為現在的feign的隔離策略是THREAD(執行緒池隔離)，這時候使用Feign的時候是單獨開啟一個執行緒的，不是之前的執行緒，所以獲取不到資料，要想使用同一個執行緒去使用feign，可以把隔離策略設定成SEMAPHORE(信號量隔離)，在order微服務的組態檔中添加一段配置

#hystrix 配置
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 10000
          strategy: SEMAPHORE

這兩種隔離策略的區別是

	執行緒池隔離	信號量隔離
執行緒	與呼叫執行緒非相同執行緒	與呼叫執行緒相同(jetty執行緒)
開銷	排隊、調度、背景關系開銷等	無執行緒切換，開銷低
異步	支持	不支持
并發支持	支持(最大執行緒池大小)	支持(最大信號量上限)

這樣就可以正常地添加資料到購物車了，

查詢購物車

查詢購物車的功能很簡單，前端攜帶著令牌向服務器發送請求，Controller呼叫相應的方法決議令牌拿到用戶名，然后呼叫Service層從Redis中獲取到對應的資料，

//	CartController
@GetMapping("/list")
public Result<List<OrderItem>> list() {
    String username = tokenDecodeUtil.getUserInfo().get("username");
    List<OrderItem> orderItems = cartService.list(username);
    return new Result<>(true,StatusCode.OK,"查詢購物車成功",orderItems);
}
//--------------------------------------------------------------------------
//     CartServiceImpl
@Override
public List<OrderItem> list(String username) {
    return (List<OrderItem>) redisTemplate.boundHashOps("Cart_" + username).values();
}

權限控制

雖然購物車的功能已經實作了，但是還存在一個問題，就是沒有對用戶進行權限校驗，我們可以去限制某個方法只能由擁有特定權限的用戶去訪問，要是不進行權限控制的話，任何人都可以訪問就會很不安全，這里我準備對購物車用到的四個方法添加“USER”權限的控制，

首先為訂單微服務和商品微服務添加OAuth2.0的依賴

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>

然后將之前提取出來的public.key檔案添加到這兩個微服務的resources目錄下，最后添加資源服務的配置類，

@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)//激活方法上的PreAuthorize注解
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    private static final String PUBLIC_KEY = "public.key";//公鑰

    /***
     * 定義JwtTokenStore
     * @param jwtAccessTokenConverter
     * @return
     */
    @Bean
    public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
        return new JwtTokenStore(jwtAccessTokenConverter);
    }

    /***
     * 定義JJwtAccessTokenConverter
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setVerifierKey(getPublicKey());
        return converter;
    }

    /**
     * 獲取非對稱加密公鑰 Key
     * @return 公鑰 Key
     */
    private String getPublicKey() {
        Resource resource = new ClassPathResource(PUBLIC_KEY);
        try {
            InputStreamReader inputStreamReader = new InputStreamReader(resource.getInputStream());
            BufferedReader br = new BufferedReader(inputStreamReader);
            return br.lines().collect(Collectors.joining("\n"));
        } catch (IOException ioe) {
            return null;
        }
    }

    /***
     * Http安全配置，對每個到達系統的http請求鏈接進行校驗
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        //所有請求必須認證通過
        http.authorizeRequests()
                .anyRequest().permitAll();//.authenticated();    //其他地址需要認證授權
    }

}

這里限制所有的請求都必須通過驗證，然后我們在相應的方法上添加注解即可，

//  SkuController
@GetMapping("/{id}")
@PreAuthorize("hasAnyAuthority('USER')")
public Result<Sku> findById(@PathVariable Long id){

//  SpuController
@GetMapping("/{id}")
@PreAuthorize("hasAnyAuthority('USER')")
public Result<Spu> findById(@PathVariable Long id){
    
//  CartController
@GetMapping("/add")
@PreAuthorize("hasAnyAuthority('USER')")
public Result add(long id,int num) {

@GetMapping("/list")
@PreAuthorize("hasAnyAuthority('USER')")
public Result<List<OrderItem>> list() {

這四個方法限制了只有擁有USER權限才可以訪問，如果沒有相應的權限請求就會被拒絕，

訂單微服務對接網關

現在就差最后一步了，就是將訂單微服務對接到網關，然后就可以通過網關將請求轉發到訂單微服務了，

在網關微服務的組態檔中添加訂單微服務的路由配置

spring:
  cloud:
      routes:
        - id: changgou_order_route
          uri: http://localhost:18089
          predicates:
            -Path=/api/cart/**,/api/categoryReport/**,/api/orderConfig/**,
            /api/order/**,/api/orderItem/**,/api/orderLog/**,/api/preferential/**,
            /api/returnCause/**,/api/returnOrder/**,/api/returnOrderItem/**
          filters:
            - StripPrefix=1

這樣就OK了，

總結

原本的代碼中，OAuth2.0是從記憶體中獲取資料，文章的開頭先是改了代碼從資料庫中獲取資料，然后實作了購物車的功能并實作了權限控制，最后將訂單微服務對接到了網關中，實作了通過網關去訪問相應的微服務，

如果我的文章對你有些幫助，不要忘了點贊，收藏，轉發，關注，要是有什么好的意見歡迎在下方留言，讓我們下期再見！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/43121.html

標籤：Java

上一篇：阿里巴巴開發10多年內部精髓都記載到這份“Java進階必備寶典”

下一篇：mysql主從復制，從原理講到安裝配置，全干貨