HttpClient

介绍

HttpClient 是 Apache 提供的一个开源的 Java HTTP 客户端库，用于发送 HTTP 请求和处理 HTTP 响应。它提供了一种更简便的方式来执行 HTTP 请求，并支持多种协议，如 HTTP、HTTPS、FTP 等。
使用 HttpClient 可以方便地与远程服务器进行通信，发送 HTTP 请求并处理响应。在实际应用中，HttpClient 常被用于与 RESTful API 交互、爬虫开发、测试等场景。

入门案例

新建一个test类进行测试

package com.sky.test;

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.json.JSONObject;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.io.UnsupportedEncodingException;

@SpringBootTest
public class HttpClientTest {
    /**
     * 测试通过HttpClientTest发送GET请求
     */
    @Test
    public void testGet() throws Exception{
        //创建HTTP对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        //创建请求对象
        HttpGet httpGet = new HttpGet("http://localhost:8080/user/shop/status");
        //发送请求
        CloseableHttpResponse response = httpClient.execute(httpGet);
        //获取服务端返回的状态码
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("服务端返回状态码："+statusCode);

        HttpEntity entity = response.getEntity();
        String body = EntityUtils.toString(entity);
        System.out.println("服务端返回数据为："+body);

        //关闭资源
        response.close();
        httpClient.close();
    }

    /**
     * 测试通过HttpClientTest发送POST请求
     */
    @Test
    public void testPost() throws Exception {
        //创建HTTP对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        //创建请求对象
        HttpPost httpPost = new HttpPost("http://localhost:8080/admin/employee/login");
        //构造JSON对象
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("username", "admin");
        jsonObject.put("password", "123456");

        StringEntity entity = new StringEntity(jsonObject.toString());
        //指定请求编码方式
        entity.setContentEncoding("utf-8");
        //数据格式
        entity.setContentType("application/json");
        httpPost.setEntity(entity);
        //发送请求
        CloseableHttpResponse response = httpClient.execute(httpPost);
        //解析返回结果
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("响应码为："+ statusCode);
        HttpEntity entity1 = response.getEntity();
        String body = EntityUtils.toString(entity1);
        System.out.println("响应数据为："+body);
        //关闭请求
        response.close();
        httpClient.close();
    }
}

微信小程序开发

介绍

准备工作

注册小程序

登录微信小程序平台按照提示进行注册

完善小程序信息

登录后进入开发管理和管理，根据页面提示信息补充小程序各项基本信息并生成密钥。

下载开发者工具

根据提示创建小程序

入门案例

获取用户信息

<!--index.wxml-->
<navigation-bar title="Weixin" back="{{false}}" color="black" background="#FFF"></navigation-bar>
<scroll-view class="scrollarea" scroll-y type="list">
  <view class="container">
    <!-- 展示动态信息 -->
    <view>
    {{meg}}
    </view>
    <button type="primary" bind:tap="getUserInfo">获取用户信息</button>
    昵称: {{nickName}}
    <image src="{{url}}" style="width: 100px;height: 100px;"></image>
  </view>
</scroll-view>

// index.js
Page({
  data:{
    meg:'hello world',
    nickName:'',
    url:''
  },
  //获取微信用户头像和昵称
  getUserInfo(){
    wx.getUserProfile({
      desc: '获取用户信息',
      success: (res) =>{
        console.log(res.userInfo)
        //为数据赋值
        this.setData({
          nickName: res.userInfo.nickName,
          url: res.userInfo.avatarUrl
        })
      }
    })
  }

})

其中需要调整数据库到2.7以下版本。具体路径为右上角详情->本地设置->调试基础库。

获取用户授权码

  data:{
    meg:'hello world',
    nickName:'',
    url:'',
    code:''
  },
  //微信登录，获取微信登录的授权码
  wxlogin(){
    wx.login({
      success: (res) => {
        console.log(res.code)
        this.setData({
          code: res.code
        })
      },
    })
  },

    <view>
      <button type="warn" bind:tap="wxlogin">微信登录</button>
      授权码：{{code}}
    </view>

发送请求

  //发送请求
  sendRequest(){
    wx.request({
      url: 'http://localhost:8080/user/shop/status',
      method:'GET',
      success: (res)=>{
        //代表后端响应的整个JSON数据
        console.log(res.data)
      }
    })
  }

    <view>
      <button type="default" bind:tap="sendRequest">发送请求</button>
    </view>

微信登录

微信登录流程

需求分析

代码开发

openid是微信用户的唯一标识
新建Controller层

@RestController
@RequestMapping("/user/user")
@Api(tags = "C端用户相关接口")
@Slf4j
public class UserController {
    @Autowired
    UserService userService;
    @Autowired
    private JwtProperties jwtProperties;
    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @PostMapping("/login")
    @ApiOperation("微信登录")
    public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO){
        log.info("微信用户登录:{}",userLoginDTO.getCode());
        //微信登录
        User user = userService.wxLogin(userLoginDTO);
        //为微信用户生成令牌
        Map<String,Object> claims=  new HashMap<>();
        claims.put(JwtClaimsConstant.USER_ID,user.getId());
        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);

        UserLoginVO userLoginVO = UserLoginVO.builder()
                .id(user.getId())
                .openid(user.getOpenid())
                .token(token)
                .build();
        return Result.success(userLoginVO);
    }
}

Service实现类

@Service
@Slf4j
public class UserServiceImpl implements UserService {
    //微信服务接口登录地址
    public static final String WX_LOGIN = "https://api.weixin.qq.com/sns/jscode2session";
    @Autowired
    private WeChatProperties weChatProperties;
    @Autowired
    private UserMapper userMapper;
    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @Override
    public User wxLogin(UserLoginDTO userLoginDTO) {
        String openid = getOpenid(userLoginDTO.getCode());
        //判断openid是否为空，如果为空表示登录失败，抛出业务异常
        if(openid == null){
            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
        }
        //是否是新用户
        User user = userMapper.getByOpenID(openid);
        //是新用户，自动完成注册
        if (user==null){
            user = User.builder()
                    .openid(openid)
                    .createTime(LocalDateTime.now())
                    .build();
        }
        userMapper.insert(user);
        //返回用户对象
        return user;
    }
    private String getOpenid(String code){
        //调用微信服务器接口服务，获得当前微信服务的openid
        Map<String,String> map = new HashMap<>();
        map.put("appid",weChatProperties.getAppid());
        map.put("secret", weChatProperties.getSecret());
        map.put("js_code", code);
        map.put("grant_type", "authorization_code");
        String json = HttpClientUtil.doGet(WX_LOGIN, map);
        JSONObject jsonObject = JSON.parseObject(json);
        String openid = jsonObject.getString("openid");
        return openid;
    }
}

Mapper接口

@Mapper
public interface UserMapper {
    @Select("select * from user where openid= #{openid}")
    User getByOpenID(String openid);

    /**
     * 插入数据
     * @param user
     */
    void insert(User user);
}

后端对应的xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sky.mapper.UserMapper">
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        insert into user (openid, name, phone, sex, id_number, avatar, create_time) VALUES
            (#{openid},#{name},#{phone},#{sex},#{idNumber},#{avatar},#{createTime})
    </insert>
</mapper>

配置web层、拦截器组件学习

对注射web层中WebMvcConfiguration的理解

    /**
     * 设置静态资源映射
     * 当访问 /doc.html路径时，Spring MVC将会去 classpath:/META-INF/resources/目录下寻找对应的静态资源
     * 而访问 /webjars/** 路径时，将会去 classpath:/META-INF/resources/webjars/目录下寻找对应的静态资源。
     * 这样做的好处是可以将一些静态资源集中存放在指定的目录，而不需要暴露给外部直接访问项目的文件结构。
     * 这有助于更好地组织项目结构，同时提供对静态资源的有效管理和映射。
     * @param registry
     */
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        log.info("开始设置静态资源映射");
        registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");

    /**
     * 扩展Spring MVC框架的消息转换器
     * 将 Java 对象转换为 JSON 数据：当服务器端需要将 Java对象转换为 JSON数据
     * 以便于发送给客户端时，消息转换器负责将 Java对象序列化为JSON格式的数据。
     * 将 JSON数据转换为 Java对象：当客户端发送包含JSON数据的请求体给服务器时
     * 消息转换器负责将接收到的JSON数据反序列化为对应的 Java对象。
     * @param converters
     */
    @Override
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        log.info("扩展消息转换器..");
        //创建一个消息转换器对象
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        //需要为消息转换器设置一个对象转换器，可以将Java对象序列化为json数据
        converter.setObjectMapper(new JacksonObjectMapper());
        //将自己的消息转换器加入容器中
        converters.add(0,converter);
    }
    /**
     * 注册自定义拦截器
     * 第一个拦截器 jwtTokenAdminInterceptor 注册在路径 /admin/**下，但排除了路径/admin/employee/login。
     * 第二个拦截器 jwtTokenUserInterceptor 注册在路径 /user/**下，但排除了路径/user/user/login和/user/shop/status。
     * 这样配置的效果是，当请求路径匹配拦截路径时，会触发相应的拦截器执行相应的逻辑。拦截器可以用于处理请求前的预处理、日志记录、权限验证等工作。
     * 通过拦截器来验证 JWT 令牌，确保请求的合法性，这在安全性要求较高的 Web 应用中是常见的做法。
     * @param registry
     */
    protected void addInterceptors(InterceptorRegistry registry) {
        log.info("开始注册自定义拦截器...");
        registry.addInterceptor(jwtTokenAdminInterceptor)
                .addPathPatterns("/admin/**")
                .excludePathPatterns("/admin/employee/login");

        registry.addInterceptor(jwtTokenUserInterceptor)
                .addPathPatterns("/user/**")
                .excludePathPatterns("/user/user/login")
                .excludePathPatterns("/user/shop/status");
    }

对jwt拦截器的理解

/**
 * jwt令牌校验的拦截器
 */
@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 校验jwt
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取当前线程id
        System.out.println("当前线程id"+Thread.currentThread().getId());
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getUserTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            //这个方法是自定义的 JWT 解析方法，接受两个参数，第一个是用于解密的密钥
            //第二个是待解析的 JWT 令牌 (token)。该方法返回一个 Claims 对象，其中包含了 JWT 中的声明信息。
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            //这一行代码从 Claims 对象中获取用户ID的声明，并将其转换成Long类型。在JWT的声明中，通常会包含一些声明（比如过期时间、签发者等）
            // 同时也会包含自定义的声明。在这里，通过 JwtClaimsConstant.USER_ID 来获取用户ID的声明。
            Long userId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
            log.info("当前用户id：", userId);
            //在拦截器中存入
            //这行代码的作用是将用户ID存入线程上下文。线程上下文是一个与线程关联的数据存储区域，可以在整个线程的生命周期内共享数据。
            //在这个具体的场景中，当用户的 JWT 令牌验证通过后，将用户的ID存入线程上下文，以便在后续的业务逻辑中能够方便地获取当前用户的ID，
            //而不必在每个方法参数中传递用户ID或者从其他地方再次获取。这样做的好处是简化了代码，提高了代码的可读性和可维护性。
            //举例来说，如果有其他地方需要使用当前用户的ID，可以通过 BaseContext.getCurrentId() 获取，
            //而不必传递用户ID的参数。这在涉及多个方法、类之间需要传递用户ID的情况下，可以减少重复代码，提高开发效率。
            BaseContext.setCurrentId(userId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

导入商品浏览功能

需求分析

代码实现

C端-分类接口

Controller层注意对注释进行命名用来区别admin的相同请求，具体实现方法可以通用。

@RestController("userCategoryController")
@Api(tags = "C端-分类接口")
@RequestMapping("/user/category")
@Slf4j
public class CategoryController {
    @Autowired
    private CategoryService categoryService;
    // Spring MVC 默认会按照参数名字和请求中的参数名字进行匹配。在你的情况下，接口路径为 /list
    // 而请求参数为 type，由于参数名字和请求中的参数名字一致，Spring MVC 可能会自动将参数值绑定到方法的参数上。
    //这是Spring MVC 的一种简化规则，适用于一些简单的情况。
    @GetMapping("/list")
    @ApiOperation("条件查询")
    /**
     * 条件查询
     */
    public Result<List<Category>> list(Integer type){
        List<Category> list = categoryService.list(type);
        return Result.success(list);
    }
}

C端-菜品浏览接口
Controller层

@RestController("userDishController")
@Api(tags = "C端-菜品浏览接口")
@RequestMapping("/user/dish")
@Slf4j
public class DishController {
    @Autowired
    private DishService dishService;

    /**
     * 根据分类id查询菜品
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询菜品")
    private Result<List<DishVO>> list(Long categoryId){
        List<DishVO> dishVOS = dishService.listWithFlavor(categoryId);
        return Result.success(dishVOS);
    }

Service实现层

    /**
     * 根据分类id查询菜品以及口味
     * @param categoryId
     * @return
     */
    @Override
    public List<DishVO> listWithFlavor(Long categoryId) {
        Dish dish = Dish.builder()
                        .categoryId(categoryId)
                        .status(StatusConstant.ENABLE)
                        .build();
        List<Dish> dishList = dishMapper.list(dish);
        List<DishVO> dishVOList = new ArrayList<>();
        for (Dish d : dishList){
            DishVO dishVO = new DishVO();
            BeanUtils.copyProperties(d, dishVO);
            List<DishFlavor> dishFlavorList = dishFlavorMapper.getByDishId(d.getId());
            dishVO.setFlavors(dishFlavorList);
            dishVOList.add(dishVO);
        }
        return dishVOList;
    }

C端-套餐浏览接口
Controller层

@RestController("userSetmealController")
@Api(tags = "C端-套餐浏览接口")
@RequestMapping("/user/setmeal")
@Slf4j
public class SetmealController {
    @Autowired
    private SetmealService setmealService;
    /**
     * 套餐浏览接口
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询套餐")
    public Result<List<Setmeal>> list(Long categoryId){
        List<Setmeal> setmeals = setmealService.list(categoryId);
        return Result.success(setmeals);
    }

    /**
     * 根据套餐id查询包含的菜品
     * @param id
     * @return
     */
    @ApiOperation("根据套餐id查询包含的菜品")
    @GetMapping("/dish/{id}")
    public Result<List<DishItemVO>> dishList(@PathVariable("id") Long id){
        List<DishItemVO> dishItemVOS = setmealService.dishList(id);
        return Result.success(dishItemVOS);
    }

Service层实现类

    /**
     * 根据分类id查询菜品
     * @param categoryId
     * @return
     */
    @Override
    public List<Setmeal> list(Long categoryId) {
        Setmeal setmeal = new Setmeal();
        setmeal.setCategoryId(categoryId);
        setmeal.setStatus(StatusConstant.ENABLE);
        List<Setmeal> setmeals = setmealMapper.list(setmeal);
        return setmeals;
    }

    /**
     * 根据套餐id查询包含的菜品
     * @param id
     * @return
     */
    @Override
    public List<DishItemVO> dishList(Long id) {
        return setmealMapper.dishList(id);
    }

Mapper接口

    /**
     * 根据分类id查询菜品
     * @param Setmeal
     * @return
     */
    List<Setmeal> list(Setmeal setmeal);

    /**
     * 根据套餐id查询包含的菜品
     * @param setmealId
     * @return
     */
    @Select("select sd.name,sd.copies,d.image,d.description from setmeal_dish sd left join dish d on sd.dish_id = d.id " +
            "where sd.setmeal_id = #{setmealId}")
    List<DishItemVO> dishList(Long setmealId);

XML底层

    <select id="list" resultType="com.sky.entity.Setmeal" parameterType="Setmeal">
        select * from setmeal
        <where>
            <if test="name != null">
                and name like concat('%',#{name},'%')
            </if>
            <if test="categoryId != null">
                and category_id = #{categoryId}
            </if>
            <if test="status != null">
                and status = #{status}
            </if>
        </where>
    </select>