项目 cg day10

最新推荐文章于 2022-05-31 09:34:13 发布
最新推荐文章于 2022-05-31 09:34:13 发布
阅读量135 收藏
点赞数 1
分类专栏： cg 文章标签： java spring cloud 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42921986/article/details/122610422
版权

第10章 购物车

学习目标

  • 资源服务器授权配置
  • 掌握OAuth认证微服务动态加载数据
  • 掌握购物车实现流程
  • OAuth2.0认证并获取用户令牌数据
  • 微服务与微服务之间的认证

1 资源服务器授权配置

1.1 资源服务授权配置

在这里插入图片描述

基本上所有微服务都是资源服务

(1)配置公钥 认证服务生成令牌采用非对称加密算法，认证服务采用私钥加密生成令牌，对外向资源服务提供公钥，资源服务使 用公钥 来校验令牌的合法性。 将公钥拷贝到 public.key文件中，将此文件拷贝到每一个需要的资源服务工程的classpath下 ,例如:用户微服务.

(2)添加依赖

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

(3)配置每个系统的Http请求路径安全控制策略以及读取公钥信息识别令牌，如下：

@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(getPubKey());
        return converter;
    }
    /**
     * 获取非对称加密公钥 Key
     * @return 公钥 Key
     */
    private String getPubKey() {
        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"). //配置地址放行
                permitAll()
                .anyRequest().
                authenticated();    //其他地址需要认证授权
    }
}
1.2 用户微服务资源授权

针对用户微服务进行权限保护，将上面生成的公钥public.key拷贝到changgou-service-user微服务工程的resources目录下，如下图：

在这里插入图片描述

(1)引入依赖

在changgou-service-user微服务工程pom.xml中引入oauth依赖

<!--oauth依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>

(2)资源授权配置

在changgou-service-user工程中创建com.changgou.user.config.ResourceServerConfig，代码如下：

@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(getPubKey());
        return converter;
    }
    /**
     * 获取非对称加密公钥 Key
     * @return 公钥 Key
     */
    private String getPubKey() {
        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"). //配置地址放行
                permitAll()
                .anyRequest().
                authenticated();    //其他地址需要认证授权
    }
}
1.3 授权测试

在这里插入图片描述

用户每次访问微服务的时候，需要先申请令牌，令牌申请后，每次将令牌放到头文件中，才能访问微服务。

头文件中每次需要添加一个Authorization头信息，头的结果为bearer token。

(1)不携带令牌测试

访问http://localhost:18089/user 不携带令牌，结果如下：

在这里插入图片描述

(2)携带正确令牌访问

访问http://localhost:18089/user 携带正确令牌，结果如下：

在这里插入图片描述

(3)携带错误令牌

访问http://localhost:18089/user 携带不正确令牌，结果如下：

在这里插入图片描述

2 OAuth对接微服务

在这里插入图片描述

用户每次访问微服务的时候，先去oauth2.0服务登录，登录后再访问微服务网关，微服务网关将请求转发给其他微服务处理。

1.用户登录成功后，会将令牌信息存入到cookie中(一般建议存入到头文件中)
2.用户携带Cookie中的令牌访问微服务网关
3.微服务网关先获取头文件中的令牌信息，如果Header中没有Authorization令牌信息，则取参数中找，参数中如果没有，则取Cookie中找Authorization，最后将令牌信息封装到Header中，并调用其他微服务
4.其他微服务会获取头文件中的Authorization令牌信息，然后匹配令牌数据是否能使用公钥解密，如果解密成功说明用户已登录，解密失败，说明用户未登录

1.1 令牌加入到Header中

修改changgou-gateway-web的全局过滤器com.changgou.filter.AuthorizeFilter，实现将令牌信息添加到头文件中，代码如下：
在这里插入图片描述

注意

将之前的jwt校验的代码注释掉，不再使用，因为已经有认证服务器，不需要网关了。

测试：

访问http://localhost:8001/api/user，将生成的新令牌放到头文件中，在令牌前面添加Bearer，这里注意有一个空格，效果如下：

在这里插入图片描述

1.2 SpringSecurity权限控制

由于我们项目使用了微服务，任何用户都有可能使用任意微服务，此时我们需要控制相关权限，例如：普通用户角色不能使用用户的删除操作，只有管理员才可以使用,那么这个时候就需要使用到SpringSecurity的权限控制功能了。

1.2.1 角色加载

在changgou-user-oauth服务中，com.changgou.oauth.config.UserDetailsServiceImpl该类实现了加载用户相关信息，如下代码：

在这里插入图片描述

上述代码给登录用户定义了三个角色，分别为admin，user，我们目前使用的是硬编码方式将角色固定，将来可以将角色存储到数据库中，从数据库中动态的进行加载。

1.2.2 角色权限控制

在每个微服务中，需要获取用户的角色，然后根据角色识别是否允许操作指定的方法，Spring Security中定义了四个支持权限控制的表达式注解，分别是@PreAuthorize、@PostAuthorize、@PreFilter和@PostFilter。其中前两者可以用来在方法调用前或者调用后进行权限检查，后两者可以用来对集合类型的参数或者返回值进行过滤。在需要控制权限的方法上，我们可以添加@PreAuthorize注解，用于方法执行前进行权限检查，校验用户当前角色是否能访问该方法。

(1)开启@PreAuthorize

在changgou-user-service的ResourceServerConfig类上添加@EnableGlobalMethodSecurity注解，用于开启@PreAuthorize的支持，代码如下：

在这里插入图片描述

(2)方法权限控制

在changgoug-service-user微服务的com.changgou.user.controller.UserController类的delete()方法上添加权限控制注解@PreAuthorize，代码如下：

在这里插入图片描述

(3)测试

我们使用Postman测试，先创建令牌，然后将令牌数存放到头文件中访问微服务网关来调用user微服务的delete方法，效果如下：

地址：http://localhost:8001/api/user/leileia 提交方式：DELETE
在这里插入图片描述

发现上面无法访问，因为用户登录的时候，角色不包含admin角色，而delete方法需要admin角色，所以被拦截了。

我们再测试其他方法，其他方法没有配置拦截，所以用户登录后就会放行。

访问http://localhost:8001/api/user

效果如下：

在这里插入图片描述

知识点说明：

如果希望一个方法能被多个角色访问，配置:@PreAuthorize("hasAnyAuthority('admin','user')")

如果希望一个类都能被多个角色访问，在类上配置:@PreAuthorize("hasAnyAuthority('admin','user')")

3 OAuth动态加载数据

前面OAuth我们用的数据都是静态的，在现实工作中，数据都是从数据库加载的，所以我们需要调整一下OAuth服务，从数据库加载相关数据。

  • 客户端数据[生成令牌相关数据]
  • 用户登录账号密码从数据库加载

3.1 客户端数据加载

3.1.1 数据介绍

(1)客户端静态数据

在changgou-user-oauth的com.changgou.oauth.config.AuthorizationServerConfig类中配置了客户端静态数据，主要用于配置客户端数据，代码如下：

在这里插入图片描述

(2)客户端表结构介绍

创建一个数据库changgou_oauth,并在数据库中创建一张表，表主要用于记录客户端相关信息，表结构如下：

CREATE TABLE `oauth_client_details` (
  `client_id` varchar(48) NOT NULL COMMENT '客户端ID，主要用于标识对应的应用',
  `resource_ids` varchar(256) DEFAULT NULL,
  `client_secret` varchar(256) DEFAULT NULL COMMENT '客户端秘钥，BCryptPasswordEncoder加密算法加密',
  `scope` varchar(256) DEFAULT NULL COMMENT '对应的范围',
  `authorized_grant_types` varchar(256) DEFAULT NULL COMMENT '认证模式',
  `web_server_redirect_uri` varchar(256) DEFAULT NULL COMMENT '认证后重定向地址',
  `authorities` varchar(256) DEFAULT NULL,
  `access_token_validity` int(11) DEFAULT NULL COMMENT '令牌有效期',
  `refresh_token_validity` int(11) DEFAULT NULL COMMENT '令牌刷新周期',
  `additional_information` varchar(4096) DEFAULT NULL,
  `autoapprove` varchar(256) DEFAULT NULL,
  PRIMARY KEY (`client_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

字段说明：

client_id：客户端id 
resource_ids：资源id（暂时不用） 
client_secret：客户端秘钥 
scope：范围 
access_token_validity：访问token的有效期（秒） 
refresh_token_validity：刷新token的有效期（秒） 
authorized_grant_type：授权类型:authorization_code,password,refresh_token,client_credentials

导入2条记录到表中，SQL如下：数据中密文分别为changgou、szitheima

INSERT INTO `oauth_client_details` VALUES ('changgou', null, '$2a$10$wZRCFgWnwABfE60igAkBPeuGFuzk74V2jw3/trkdUZpnteCtJ9p9m', 'app', 'authorization_code,password,refresh_token,client_credentials', 'http://localhost', null, '432000000', '432000000', null, null);
INSERT INTO `oauth_client_details` VALUES ('szitheima', null, '$2a$10$igxoCZxTbjWx5TrmfWEEpe/WFdwbUhbxik9BKTe9i64ZOSfnu/lqe', 'app', 'authorization_code,password,refresh_token,client_credentials', 'http://localhost', null, '432000000', '432000000', null, null);

上述表结构属于SpringSecurity Oauth2.0所需的一个认证表结构，不能随意更改。相关操作在其他类中有所体现，如：org.springframework.security.oauth2.provider.client.JdbcClientDetailsService中的片段代码如下：

在这里插入图片描述

3.1.2 加载数据改造

(1)修改连接配置

从数据库加载数据，我们需要先配置数据库连接，在changgou-user-oauth的application.yml中配置连接信息，如下代码：如果是一致的，则不用修改。

在这里插入图片描述

上图代码如下：

  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.211.132:3306/changgou_oauth?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true&serverTimezone=UTC
    username: root
    password: 123456

(2)修改客户端加载源

修改changgou-user-oauth的com.changgou.oauth.config.AuthorizationServerConfig类的configure方法，将之前静态的客户端数据变成从数据库加载，修改如下：

修改前：

在这里插入图片描述

修改后：

在这里插入图片描述

(4)测试

授权码模式测试

访问：http://localhost:9001/oauth/authorize?client_id=szitheima&response_type=code&scop=app&redirect_uri=http://localhost

注意client_id这个值一定要写成数据库本身就有的，否指出错

效果如下：
在这里插入图片描述

账号输入：szitheima 密码：szitheima，注意，这里还是密码只要是szitheima就可以了。效果如下：

在这里插入图片描述

POSTMAN中申请令牌：如图，填写basic auth 右边的用户名和密码填写的和数据库的表oauth_client_details中的client_id和client_secret保持一致。

在这里插入图片描述

请求体：

在这里插入图片描述

密码模式授权测试

密码模式：只需要输入用户密码为szitheima即可。需要注意的是：我们一定要有账号为changgou和畅购的客户端存在，而数据库是存在的。此客户端目前给我们自己的系统使用。

在这里插入图片描述

登录的方法暂时不变如下图所示：

在这里插入图片描述

所以用户每次输入账号和密码，只要密码是szitheima，即可登录成功。访问地址http://localhost:9001/user/login

输入账号密码均为szitheima,效果如下：

在这里插入图片描述

3.2 用户数据加载

分析：如图所示，目前我们的用户名随意写，只要密码为szitheima即可，但是真实应用场景肯定是不能这样的，需要动态的从用户数据库里面进行校验。

在这里插入图片描述

分析需求图如下：

在这里插入图片描述

1.用户访问认证服务器
2.认证服务器调用feign获取用户的信息，并进行校验
3.如果校验通过则通过私钥进行加密并返回令牌信息
4.令牌信息携带到网关 
5.网关进行令牌信息过滤传递给下游系统微服务
6.微服务自动进行公钥校验如果校验通过则说明校验通过，放行请求

(1)Feign创建

在changgou-service-user-api中创建com.changgou.user.feign.UserFeign，代码如下：

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

    /***
     * 根据ID查询用户信息
     * @param id
     * @return
     */
    @GetMapping("/load/{id}")
    Result<User> findById(@PathVariable(name="id") String id);
}

(2)修改UserController

修改changgou-service-user的UserController，添加一个方法loadById专门用作登录使用：

//获取用户的信息
@GetMapping("/load/{id}")
public Result<User> loadById(@PathVariable(name="id") String id) {
    //调用UserService实现根据主键查询User
     User user =  userService.selectByPrimaryKey(id);
    return new Result<User>(true, StatusCode.OK, "查询成功", user);
}

(3)放行查询用户方法

因为oauth需要调用查询用户信息，需要在changgou-service-user中放行/user/load/{id}方法,修改ResourceServerConfig，添加对/user/load/{id}的放行操作，代码如下：

在这里插入图片描述

(4)oauth调用查询用户信息changgou-oauth工程中引入对user-api的依赖

<!--依赖用户api-->
<dependency>
    <groupId>com.changgou</groupId>
    <artifactId>changgou-service-user-api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

修改oauth的com.changgou.oauth.config.UserDetailsServiceImpl的loadUserByUsername方法，调用UserFeign查询用户信息，代码如下：

在这里插入图片描述

(5)feign开启

修改com.changgou.OAuthApplication开启Feign客户端功能

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages = {"com.changgou.user.feign"})
@MapperScan(basePackages = "com.changgou.auth.dao")
public class OAuthApplication {

    public static void main(String[] args) {
        SpringApplication.run(OAuthApplication.class,args);
    }


    @Bean(name = "restTemplate")
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

(6)测试

我们测试时使用数据库中的账号密码登录，分别输入zhangsan，效果如下：
在这里插入图片描述

4 购物车

购物车分为用户登录购物车和未登录购物车操作，国内知名电商京东用户登录和不登录都可以操作购物车，如果用户不登录，操作购物车可以将数据存储到Cookie或者WebSQL或者SessionStorage中，用户登录后购物车数据可以存储到Redis中，再将之前未登录加入的购物车合并到Redis中即可。

淘宝天猫则采用了另外一种实现方案，用户要想将商品加入购物车，必须先登录才能操作购物车。

我们今天实现的购物车是天猫解决方案，即用户必须先登录才能使用购物车功能。

4.1 购物车分析

(1)需求分析

用户在商品详细页点击加入购物车，提交商品SKU编号和购买数量，添加到购物车。购物车展示页面如下：

在这里插入图片描述

(2)购物车实现思路

在这里插入图片描述

我们实现的是用户登录后的购物车，用户将商品加入购物车的时候，直接将要加入购物车的详情存入到Redis即可。每次查看购物车的时候直接从Redis中获取。

(3)表结构分析

用户登录后将商品加入购物车，需要存储商品详情以及购买数量，购物车详情表如下：

changgou_order数据中tb_order_item表：

CREATE TABLE `tb_order_item` (
  `id` varchar(20) COLLATE utf8_bin NOT NULL COMMENT 'ID',
  `category_id1` int(11) DEFAULT NULL COMMENT '1级分类',
  `category_id2` int(11) DEFAULT NULL COMMENT '2级分类',
  `category_id3` int(11) DEFAULT NULL COMMENT '3级分类',
  `spu_id` varchar(20) COLLATE utf8_bin DEFAULT NULL COMMENT 'SPU_ID',
  `sku_id` bigint(20) NOT NULL COMMENT 'SKU_ID',
  `order_id` bigint(20) NOT NULL COMMENT '订单ID',
  `name` varchar(200) COLLATE utf8_bin DEFAULT NULL COMMENT '商品名称',
  `price` int(20) DEFAULT NULL COMMENT '单价',
  `num` int(10) DEFAULT NULL COMMENT '数量',
  `money` int(20) DEFAULT NULL COMMENT '总金额',
  `pay_money` int(11) DEFAULT NULL COMMENT '实付金额',
  `image` varchar(200) COLLATE utf8_bin DEFAULT NULL COMMENT '图片地址',
  `weight` int(11) DEFAULT NULL COMMENT '重量',
  `post_fee` int(11) DEFAULT NULL COMMENT '运费',
  `is_return` char(1) COLLATE utf8_bin DEFAULT NULL COMMENT '是否退货',
  PRIMARY KEY (`id`),
  KEY `item_id` (`sku_id`),
  KEY `order_id` (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

购物车详情表其实就是订单详情表结构，只是目前临时存储数据到Redis，等用户下单后才将数据从Redis取出存入到MySQL中。

在商城中一般都会有不同分类商品做折扣活动，下面有一张表记录了对应分类商品的折扣活动，每类商品只允许参与一次折扣活动。

changgou_goods数据中tb_pref表：

CREATE TABLE `tb_pref` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `cate_id` int(11) DEFAULT NULL COMMENT '分类ID',
  `buy_money` int(11) DEFAULT NULL COMMENT '消费金额',
  `pre_money` int(11) DEFAULT NULL COMMENT '优惠金额',
  `start_time` date DEFAULT NULL COMMENT '活动开始日期',
  `end_time` date DEFAULT NULL COMMENT '活动截至日期',
  `type` char(1) DEFAULT NULL COMMENT '类型,1:普通订单，2：限时活动',
  `state` char(1) DEFAULT NULL COMMENT '状态,1:有效，0：无效',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

4.2 订单购物车微服务

我们先搭建一个订单购物车微服务工程，按照如下步骤实现即可。

(0) 引入依赖

changgou-service-order中引入changgou-service-order-api

<dependency>
    <groupId>com.changgou</groupId>
    <artifactId>changgou-service-order-api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
    <groupId>com.changgou</groupId>
    <artifactId>changgou-core-controller</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

(1)导入资源

搭建订单购物车微服务，工程名字changgou-service-order并搭建对应的api工程changgou-service-order-api,将生成好的dao和相关文件拷贝到工程中，以及生成好的Pojo拷贝到API工程中，如下图

changgou-service-order:
在这里插入图片描述

changgou-service-order-api:

在这里插入图片描述

(2)application.yml配置

在changgou-service-order的resources中添加application.yml配置文件，代码如下：

server:
  port: 18090
spring:
  application:
    name: order
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.211.132:3306/changgou_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: 123456
  redis:
    host: 192.168.211.132
    port: 6379
  main:
    allow-bean-definition-overriding: true

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:7001/eureka
  instance:
    prefer-ip-address: true
feign:
  hystrix:
    enabled: true

(3)创建启动类

在changgou-service-order的resources中创建启动类，代码如下：

@SpringBootApplication
@EnableEurekaClient
@MapperScan(basePackages = {"com.changgou.order.dao"})
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class,args);
    }
}

4.3 添加购物车

4.3.1 思路分析

在这里插入图片描述

用户添加购物车，只需要将要加入购物车的商品存入到Redis中即可。一个用户可以将多件商品加入购物车，存储到Redis中的数据可以采用Hash类型。

选Hash类型可以将用户的用户名作为namespace的一部分，将指定商品加入购物车，则往对应的namespace中增加一个key和value，key是商品ID，value是加入购物车的商品详情，如下图：

在这里插入图片描述

4.3.2 代码实现

(1)feign创建

下订单需要调用feign查看商品信息，我们先创建feign分别根据ID查询Sku和Spu信息，在changgou-service-goods-api工程中的SkuFeign和SpuFeign根据ID查询方法如下：

在这里插入图片描述

com.changgou.goods.feign.SkuFeign

/***
 * 根据ID查询SKU信息
 * @param id : sku的ID
 */
@GetMapping(value = "/{id}")
public Result<Sku> findById(@PathVariable(value = "id", required = true) Long id);

com.changgou.goods.feign.SpuFeign

在这里插入图片描述

/***
 * 根据SpuID查询Spu信息
 * @param id
 * @return
 */
@GetMapping("/{id}")
public Result<Spu> findById(@PathVariable(name = "id") Long id);

(2)业务层

业务层接口

在changgou-service-order微服务中创建com.changgou.order.service.CartService接口，代码如下：

public interface CartService {

    /***
     * 添加购物车
     * @param num:购买商品数量
     * @param id：购买ID
     * @param username：购买用户
     * @return
     */
    void add(Integer num, Long id, String username);
}

业务层接口实现类

在changgou-service-order微服务中创建接口实现类com.changgou.order.service.impl.CartServiceImpl,代码如下：

@Service
public class CartServiceImpl implements CartService {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private SkuFeign skuFeign;

    @Autowired
    private SpuFeign spuFeign;


    /***
     * 加入购物车
     * @param num:购买商品数量
     * @param id：购买ID
     * @param username：购买用户
     * @return
     */
    @Override
    public void add(Integer num, Long id, String username) {
        //查询SKU
        Result<Sku> resultSku = skuFeign.findById(id);
        if(resultSku!=null && resultSku.isFlag()){
            //获取SKU
            Sku sku = resultSku.getData();
            //获取SPU
            Result<Spu> resultSpu = spuFeign.findById(sku.getSpuId());

            //将SKU转换成OrderItem
            OrderItem orderItem = sku2OrderItem(sku,resultSpu.getData(), num);

            /******
             * 购物车数据存入到Redis
             * namespace = Cart_[username]
             * key=id(sku)
             * value=OrderItem
             */
            redisTemplate.boundHashOps("Cart_"+username).put(id,orderItem);
        }
    }

    /***
     * SKU转成OrderItem
     * @param sku
     * @param num
     * @return
     */
    private OrderItem sku2OrderItem(Sku sku,Spu spu,Integer num){
        OrderItem orderItem = new OrderItem();
        orderItem.setSpuId(sku.getSpuId());
        orderItem.setSkuId(sku.getId());
        orderItem.setName(sku.getName());
        orderItem.setPrice(sku.getPrice());
        orderItem.setNum(num);
        orderItem.setMoney(num*orderItem.getPrice());       //单价*数量
        orderItem.setPayMoney(num*orderItem.getPrice());    //实付金额
        orderItem.setImage(sku.getImage());
        orderItem.setWeight(sku.getWeight()*num);           //重量=单个重量*数量

        //分类ID设置
        orderItem.setCategoryId1(spu.getCategory1Id());
        orderItem.setCategoryId2(spu.getCategory2Id());
        orderItem.setCategoryId3(spu.getCategory3Id());
        return orderItem;
    }
}

(3)控制层

在changgou-service-order微服务中创建com.changgou.order.controller.CartController，代码如下：

@RestController
@CrossOrigin
@RequestMapping(value = "/cart")
public class CartController {

    @Autowired
    private CartService cartService;

    /***
     * 加入购物车
     * @param num:购买的数量
     * @param id：购买的商品(SKU)ID
     * @return
     */
    @RequestMapping(value = "/add")
    public Result add(Integer num, Long id){
        //用户名
        String username="szitheima";
        //将商品加入购物车
        cartService.add(num,id,username);
        return new Result(true, StatusCode.OK,"加入购物车成功！");
    }
}

(4)feign配置

修改com.changgou.OrderApplication开启Feign客户端：

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.changgou.goods.feign"})
@MapperScan(basePackages = {"com.changgou.order.dao"})
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class,args);
    }
}

测试添加购物车，效果如下：

请求地址http://localhost:18090/cart/add?num=6&id=1148477873175142400

在这里插入图片描述

Redis缓存中的数据

在这里插入图片描述

4.4 购物车列表

4.4.1 思路分析

在这里插入图片描述

接着我们实现一次购物车列表操作。因为存的时候是根据用户名往Redis中存储用户的购物车数据的，所以我们这里可以将用户的名字作为key去Redis中查询对应的数据。

4.4.2 代码实现

(1)业务层

业务层接口

修改changgou-service-order微服务的com.changgou.order.service.CartService接口，添加购物车列表方法，代码如下：

/***
 * 查询用户的购物车数据
 * @param username
 * @return
 */
List<OrderItem> list(String username);

业务层接口实现类

修改changgou-service-order微服务的com.changgou.order.service.impl.CartServiceImpl类，添加购物车列表实现方法，代码如下：

/***
 * 查询用户购物车数据
 * @param username
 * @return
 */
@Override
public List<OrderItem> list(String username) {
    //查询所有购物车数据
    List<OrderItem> orderItems = redisTemplate.boundHashOps("Cart_"+username).values();
    return orderItems;
}

(2)控制层

修改changgou-service-order微服务的com.changgou.order.controller.CartController类，添加购物车列表查询方法，代码如下：

/***
 * 查询用户购物车列表
 * @return
 */
@GetMapping(value = "/list")
public Result list(){
    //用户名
    String username="szitheima";
    List<OrderItem> orderItems = cartService.list(username);
    return new Result(true,StatusCode.OK,"购物车列表查询成功！",orderItems);
}

(3)测试

使用Postman访问 GET http://localhost:18090/cart/list ,效果如下：

在这里插入图片描述

4.4.3 问题处理

(1)删除商品购物车

在这里插入图片描述

我们发现个问题，就是用户将商品加入购物车，无论数量是正负，都会执行添加购物车，如果数量如果<=0，应该移除该商品的。

修改changgou-service-order的com.changgou.order.service.impl.CartServiceImpl的add方法，添加如下代码：

在这里插入图片描述

5 微服务用户身份识别

5.1 网关过滤

为了不给微服务带来一些无效的请求，我们可以在网关中过滤用户请求，先看看头文件中是否有Authorization，如果有再看看cookie中是否有Authorization，如果都通过了才允许请求到达微服务。

5.2 订单对接网关+oauth

(1)application.yml配置

修改微服务网关changgou-gateway-web的application.yml配置文件，添加order的路由过滤配置，配置如下：

在这里插入图片描述

上图代码如下：

            #订单微服务
            - id: changgou_order_route
              uri: lb://order
              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

这里注意使用的是yml格式，所以上面代码中的空格也一并记得拷贝到application.yml文件中。

(2)changgou-service-order集成OAuth进行安全校验

修改changgou-service-order的pom.xml，添加oauth的依赖

<!--oauth依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>

将公钥拷贝到changgou-service-order工程的resources中
在这里插入图片描述

在changgou-service-order工程中创建com.changgou.order.config.ResourceServerConfig,配置需要拦截的路径，这里需要拦截所有请求路径，代码如下：

@Configuration
@EnableResourceServer
//开启方法上的PreAuthorize注解
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
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(getPubKey());
        return converter;
    }
    /**
     * 获取非对称加密公钥 Key
     * @return 公钥 Key
     */
    private String getPubKey() {
        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().
                authenticated();    //其他地址需要认证授权
    }
}

(5)测试

使用浏览器访问 http://localhost:8001/api/cart/list，效果如下：

未登录：

在这里插入图片描述

使用Postman访问 http://localhost:8001/api/cart/list，效果如下：

已登录：

在这里插入图片描述

5.3 购物车需求分析

5.3.1 业务流程分析

在这里插入图片描述

如图所示，添加购物车
1.需要先通过feign调用商品微服务
2.获取商品数据，添加至redis中

问题：如果每一个微服务都进行了公钥权限保护，那么意味着我们每一个微服务直接的调用同样需要认证。而微服务直接的调用是根据业务的方式变化而变化的。

5.3.2 模拟测试调用

changgou-service-goods微服务添加安全校验，步骤如下：

（1）添加依赖changgou-service-goods微服务中添加依赖

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

(2) changgou-service-goods微服务中创建包com.changgou.goods.config 并创建配置类ResourceServerConfig

@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(getPubKey());
        return converter;
    }

    /**
     * 获取非对称加密公钥 Key
     *
     * @return 公钥 Key
     */
    private String getPubKey() {
        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().
                authenticated();    //其他地址需要认证授权
    }
}

（3）copy changgou-oauth微服务中的public.key文件到changgou-service-goods微服务中的resouces目录下

在这里插入图片描述

（4）再次启动changgou-service-goods 和changgou-service-order进行测试添加购物车的时候报错。

至此演示结束。思考：为什么报错？怎么解决？

5.4 微服务之间认证

在这里插入图片描述

如上图：由于微服务直接调用也需要传递token 进行认证，而因为微服务之间并没有传递头文件，所以我们可以定义一个拦截器，每次微服务调用之前都先检查下头文件，将请求的头文件中的令牌数据存储到header 传递给被调用的微服务即可，微服务此时公钥自动校验头信息如果校验通过则放行请求，可以调用。

(1)创建拦截器

在changgou-service-order微服务中创建一个com.changgou.order.config.MyFeignInterceptor拦截器，并将所有头文件数据再次加入到Feign请求的微服务头文件中，代码如下：

@Component
public class MyFeignInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate requestTemplate) {
        try {
            //使用RequestContextHolder工具获取request相关变量
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (attributes != null) {
                //取出request
                HttpServletRequest request = attributes.getRequest();
                //获取所有头文件信息的key
                Enumeration<String> headerNames = request.getHeaderNames();
                if (headerNames != null) {
                    while (headerNames.hasMoreElements()) {
                        //头文件的key
                        String name = headerNames.nextElement();
                        //头文件的value
                        String values = request.getHeader(name);
                        //将令牌数据添加到头文件中
                        requestTemplate.header(name, values);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

(2)测试

在这里插入图片描述

我们发现这块的ServletRequestAttributes始终为空，RequestContextHolder.getRequestAttributes()该方法是从ThreadLocal变量里面取得相应信息的，当hystrix断路器的隔离策略为THREAD时，是无法取得ThreadLocal中的值。

解决方案：

  • hystrix隔离策略换为SEMAPHORE
  • 关闭hystirx

修改changgou-service-order的application.yml配置文件，在application.yml中添加如下代码，代码如下：

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

再次测试，效果如下：

在这里插入图片描述

5.5 获取用户数据

5.5.1 数据分析

用户登录后，数据会封装到SecurityContextHolder.getContext().getAuthentication().getDetails（）里面，我们可以将数据从这里面取出，然后转换成OAuth2AuthenticationDetails,在这里面可以获取到令牌信息、令牌类型等，代码如下：

在这里插入图片描述

这里的tokenValue是加密之后的令牌数据，remoteAddress是用户的IP信息，tokenType是令牌类型。

我们可以获取令牌加密数据后，使用公钥对它进行解密，如果能解密说明说句无误，如果不能解密用户也没法执行到这一步。解密后可以从明文中获取用户信息。

5.5.2 代码实现

(1)编写工具类方法并获取解析到的令牌数据

在changgou-service-order项目工程中创建TokenDecode类在com.changgou.order.config包下，交给spring容器管理，用于获取当前登录的用户信息，代码如下：

@Component
public class TokenDecode {
    private static final String PUBLIC_KEY = "public.key";

    private String getPubKey() {
        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;
        }
    }

    /**
     * 获取用户信息
     * @return
     */
    public Map<String, String> getUserInfo() {
        //1.根据ID 调用goods的feign获取商品的数据
        //2.将数据存储到redis的 某一个登录的用户的 购物车中 key: value
        OAuth2AuthenticationDetails details = (OAuth2AuthenticationDetails) SecurityContextHolder.getContext().getAuthentication().getDetails();
        //1.先获取到令牌的信息
        String tokenValue = details.getTokenValue();
        //校验Jwt
        Jwt jwt = JwtHelper.decodeAndVerify(tokenValue, new RsaVerifier(getPubKey()));
        //获取Jwt原始内容
        //2.解析令牌信息 获取到username的值 当前的登录的用户的用户名
        String claims = jwt.getClaims();

        Map<String, String> map = JSON.parseObject(claims, Map.class);

        return map;
    }
    //获取用户名

    public String getUsername() {
        return getUserInfo().get("user_name");
    }
}

(2)控制层获取用户数据

在CartController中注入TokenDecode，并调用TokenDecode的getUsername方法获取用户信息，代码如下：

注入TokenDecode：

@Autowired
private TokenDecode tokenDecode;

获取用户名：

在这里插入图片描述

(5)测试

用户登录后测试http://localhost:8001/api/wcart/list

断点调试可以获取到用户名信息：

在这里插入图片描述

请求结果：

在这里插入图片描述

5.6注意

不要在common中添加security的和oauth2.0的依赖包.需要的地方再加.不需要抽取到common中.哪里需要哪里加入依赖即可.

改改我的代码吧
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java黑马商城代码文档数据库
12-05
黑马课程最后一个大项目代码文档数据库，黑马课程最后一个大项目代码文档数据库，黑马课程最后一个大项目代码文档数据库
javaweb黑马商城项目+数据库后台
01-08
javaweb商城，这是我根据黑马的视频做了，测试运行后可以使用，功能完美，界面你美观，可以当作学习javaweb的项目练手。
黑马乐优商城数据库脚本，与视频一致包含所有表
03-29
乐优商城最新SQL（包含spec_param等表和数据），大小是1.1m
2019期黑马乐优商城项目，数据库脚本文件
qq_41621703的博客
06-13 4057
- 2019期黑马乐优商城项目，数据库脚本文件，它自带的脚本文件导入有问题，我修改了一下，能成功导入，并能完成整个项目的读写数据操作。下关链接： 插入链接与图片 链接：https://pan.baidu.com/s/1ADDcJmhbWGA_9xxVd3ppFA 提取码：mvpz 复制这段内容后打开百度网盘手机App，操作更方便哦 ...
黑马畅购商城---10.购物车
IT大神帅杰的博客
02-23 2731
学习目标 资源服务器授权配置 掌握OAuth认证微服务动态加载数据 掌握购物车流程 掌握购物车渲染流程 OAuth2.0认证并获取用户令牌数据 微服务与微服务之间的认证 畅购商城全套-升级修复版-.md课件等等.... 网盘链接 链接：https://pan.baidu.com/s/1uRYMRXxjRw6BOy7IMOYcQA1 提取码：o8df ...
CG动画项目商业计划书.doc
03-14
本商业计划书旨在详尽阐述一个CG动画项目的全面规划，以吸引潜在投资者和制作发行商的关注。 第一章，XX动画行业状况，主要探讨了CG动画行业的现状和发展趋势。这包括全球及中国市场的发展规模、增长速度、主要参与...
Cg.rar_Cg
09-22
CG”原为Computer Graphics的英文缩写。随着以计算机为主要工具进行视觉设计和生产的一系列相关产业的形成,国际上习惯将利用计算机技术进行视觉设计和生产的领域通称为CG。它既包括技术也包括艺术，几乎囊括了当今...
CG.rar_Cg
09-19
CG资料，很不错的，大家可以下载用用，包括使用手册和说明
CG文件项目创建
09-25
CG文件项目创建
CG.zip_Cg
09-20
CG算法，需要Q矩阵或者D 矩阵的可以私聊
黑马乐优商城项目最新Sql文件
01-10
最新的视频我也看了，也自己做了，用该sql文件完全没有问题。该数据库有一个用户：用户名跟密码都是：admin；如果没有买短信服务的可以用该账号测试！该sql 文件是最新视频里面用得sql文件，为1.1M多。不是老的sql文件，老的sql文件的大小为1.4M.如果又问题可以留言评论，看到我会答复的，谢谢 ! 各位测试了能用的就给我个好评，谢谢了！
新版畅购商城数据库sql文件
11-22
畅购商城项目的数据库脚本，主要包括changgou_all、changgou_content、changgou_oauth、changgou_business、changgou_config、changgou_goods、changgou_order、changgou_seckill、changgou_system、changgou_user 10个数据库
畅购商城数据库完整版
05-08
畅购商城项目的数据库脚本，主要包括changgou_all、changgou_content、changgou_oauth、changgou_business、changgou_config、changgou_goods、changgou_order、changgou_seckill、changgou_system、changgou_user 10个数据库
畅购商城项目的数据库脚本文件
02-21
畅购商城项目的数据库脚本，主要包括changgou_business、changgou_config、changgou_goods、changgou_order、changgou_seckill、changgou_system、changgou_user
黑马商城加后端管理。。
03-15
使用servlet+jsp实现的黑马商城系统，使用mysql作为数据库，数据库下载链接：https://pan.baidu.com/s/1MIvn8bbjanuwVGz72rwsjw 提取码：2c6w
黑马学习商城项目使用mysql数据库遇到Cannot add or update a child row: a foreign key constraint fails (`ssm`.`orders`
weixin_41951986的博客
09-15 210
商城项目上使用mysql数据库插入数据库order报错进行外表链接报错： Cannot add or update a child row: a foreign key constraint fails (`ssm`.`orders` 说我的数据库不能添加个foreign？ 问题所在：我在创建表的时候次序是product --> member --> traveller --> orders --> order_traveller 但是我insert数据的时候，由于orders的数
黑马商城02
Life is short,use python
03-16 173
商城项目第二天 今日任务 完成首页的分类数据加载 首页商品数据的加载 商品详情的加载 某个分类下商品列表展示(分页) 今日基本套路: 由页面加载完成以后 发请求到服务器 要数据 数据拿到以后 拼字符串 到对应位置 分类数据加载 ...
黑马优购商城项目01
xumengxia的博客
08-13 525
1.
黑马程序之畅购商城学习
weixin_44381728的博客
05-31 412
Day 1 系统架构图 项目搭建 商品微服务的搭建 技术栈： tk-mybatis 实现功能：CRUD
java微服务项目频繁cg
最新发布
12-07
以下是关于Java微服务项目频繁CG的介绍和解决方法： Java微服务项目频繁CG的原因可能是由于内存泄漏或内存溢出导致的。内存泄漏是指程序中已经不再使用的对象没有被垃圾回收器回收，导致内存占用越来越高，最终导致...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值