package com.heima.utils.common;


import java.util.*;

public class SensitiveWordUtil {

    public static Map<String, Object> dictionaryMap = new HashMap<>();


    /**
     * 生成关键词字典库
     * @param words
     * @return
     */
    public static void initMap(Collection<String> words) {
        if (words == null) {
            System.out.println("敏感词列表不能为空");
            return ;
        }

        // map初始长度words.size()，整个字典库的入口字数(小于words.size()，因为不同的词可能会有相同的首字)
        Map<String, Object> map = new HashMap<>(words.size());
        // 遍历过程中当前层次的数据
        Map<String, Object> curMap = null;
        Iterator<String> iterator = words.iterator();

        while (iterator.hasNext()) {
            String word = iterator.next();
            curMap = map;
            int len = word.length();
            for (int i =0; i < len; i++) {
                // 遍历每个词的字
                String key = String.valueOf(word.charAt(i));
                // 当前字在当前层是否存在, 不存在则新建, 当前层数据指向下一个节点, 继续判断是否存在数据
                Map<String, Object> wordMap = (Map<String, Object>) curMap.get(key);
                if (wordMap == null) {
                    // 每个节点存在两个数据: 下一个节点和isEnd(是否结束标志)
                    wordMap = new HashMap<>(2);
                    wordMap.put("isEnd", "0");
                    curMap.put(key, wordMap);
                }
                curMap = wordMap;
                // 如果当前字是词的最后一个字，则将isEnd标志置1
                if (i == len -1) {
                    curMap.put("isEnd", "1");
                }
            }
        }

        dictionaryMap = map;
    }

    /**
     * 搜索文本中某个文字是否匹配关键词
     * @param text
     * @param beginIndex
     * @return
     */
    private static int checkWord(String text, int beginIndex) {
        if (dictionaryMap == null) {
            throw new RuntimeException("字典不能为空");
        }
        boolean isEnd = false;
        int wordLength = 0;
        Map<String, Object> curMap = dictionaryMap;
        int len = text.length();
        // 从文本的第beginIndex开始匹配
        for (int i = beginIndex; i < len; i++) {
            String key = String.valueOf(text.charAt(i));
            // 获取当前key的下一个节点
            curMap = (Map<String, Object>) curMap.get(key);
            if (curMap == null) {
                break;
            } else {
                wordLength ++;
                if ("1".equals(curMap.get("isEnd"))) {
                    isEnd = true;
                }
            }
        }
        if (!isEnd) {
            wordLength = 0;
        }
        return wordLength;
    }

    /**
     * 获取匹配的关键词和命中次数
     * @param text
     * @return
     */
    public static Map<String, Integer> matchWords(String text) {
        Map<String, Integer> wordMap = new HashMap<>();
        int len = text.length();
        for (int i = 0; i < len; i++) {
            int wordLength = checkWord(text, i);
            if (wordLength > 0) {
                String word = text.substring(i, i + wordLength);
                // 添加关键词匹配次数
                if (wordMap.containsKey(word)) {
                    wordMap.put(word, wordMap.get(word) + 1);
                } else {
                    wordMap.put(word, 1);
                }

                i += wordLength - 1;
            }
        }
        return wordMap;
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("法轮");
        list.add("法轮功");
        list.add("冰毒");
        //初始化敏感词库
        initMap(list);
        String content="我是一个好人，并不会卖冰毒，也不操练法轮功,我真的不卖冰毒";
        Map<String, Integer> map = matchWords(content);
        System.out.println(map);
    }
}

package com.atguigu.gulimall.product.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

import lombok.Data;

/**
 * 商品三级分类
 * 
 * @author JasonGong
 * @email JasonGong@gmail.com
 * @date 2023-05-19 00:23:36
 */
@Data
@TableName("pms_category")
public class CategoryEntity implements Serializable {
	private static final long serialVersionUID = 1L;

	/**
	 * 分类id
	 */
	@TableId
	private Long catId;
	/**
	 * 分类名称
	 */
	private String name;
	/**
	 * 父分类id
	 */
	private Long parentCid;
	/**
	 * 层级
	 */
	private Integer catLevel;
	/**
	 * 是否显示[0-不显示，1显示]
	 */
	private Integer showStatus;
	/**
	 * 排序
	 */
	private Integer sort;
	/**
	 * 图标地址
	 */
	private String icon;
	/**
	 * 计量单位
	 */
	private String productUnit;
	/**
	 * 商品数量
	 */
	private Integer productCount;

	@TableField(exist = false)//这个注解要加，因为这个属性不是数据库中的字段
	private List<CategoryEntity> children;//这里的属性名不是瞎起的,与ElementUI中的显示相对应,这里改了，前端也要改

}

/**
  * 查询所有的分类以及子分类，以树形结构组装起来
  */
@RequestMapping("/list/tree")
public R list(){
    List<CategoryEntity> entities =  categoryService.listWithTree();
    return R.ok().put("data", entities);
}

/**
   * 查询所有分类，以树形结构显示
   */
  @Override
  public List<CategoryEntity> listWithTree() {
      //查出所有的分类
      List<CategoryEntity> entities = categoryDao.selectList(null);
      //组装成父子的树形结构
      //找到所有的一级分类
      List<CategoryEntity> level1List = entities.stream().filter(categoryEntity ->
              //父级分类的id等于0的就是一级分类
              categoryEntity.getParentCid() == 0
      ).map((menu) -> {
          //为当前分类的子分类赋值
          menu.setChildren(getChildren(menu, entities));
          return menu;
      }).sorted((menu1, menu2) -> {
          //排序
          return (menu1.getSort() == null ? 0 : menu1.getSort()) - (menu2.getSort() == null ? 0 : menu2.getSort());
      }).collect(Collectors.toList());

      return level1List;
  }

  /**
   * 递归查询所有菜单的子菜单
   *
   * @param root 当前分类
   * @param all  所有的分类数据
   * @return 子菜单的集合
   */
  private List<CategoryEntity> getChildren(CategoryEntity root, List<CategoryEntity> all) {
      List<CategoryEntity> children = all.stream().filter(categoryEntity -> {
          return categoryEntity.getParentCid().equals(root.getCatId());
      }).map(categoryEntity -> {
          //1.递归找子菜单
          categoryEntity.setChildren(getChildren(categoryEntity, all));
          return categoryEntity;
      }).sorted((menu1, menu2) -> {
          //2.菜单的排序
          return (menu1.getSort() == null ? 0 : menu1.getSort()) - (menu2.getSort() == null ? 0 : menu2.getSort());
      }).collect(Collectors.toList());
      return children;
  }

/**
   * 删除
   */
  @RequestMapping("/delete")
  //@RequiresPermissions("product:category:delete")
  public R delete(@RequestBody Long[] catIds) {
      //检查当前删除的菜单，是否被别的地方引用
      //categoryService.removeByIds(Arrays.asList(catIds));
      categoryService.removeMenuByIds(Arrays.asList(catIds));
      return R.ok();
  }

/**
  * 保存
  */
@RequestMapping("/save")
//@RequiresPermissions("product:category:save")
public R save(@RequestBody CategoryEntity category) {
    categoryService.save(category);

    return R.ok();
}

package com.atguigu.yygh.common.helper;

import io.jsonwebtoken.*;
import org.springframework.util.StringUtils;

import java.util.Date;

/**
 * @author GongChangjiang
 * @version 1.0
 * @Date 2023/4/20
 * @Description
 */
public class JwtHelper {
    private static long tokenExpiration = 24*60*60*1000;  //token的过期时间
    private static String tokenSignKey = "123456";  //token 签名的密钥

    /**
     * 根据参数生成token
     * @param userId 用户的id
     * @param userName 用户名
     * @return token字符串
     */
    public static String createToken(Long userId, String userName) {
        String token = Jwts.builder()
                .setSubject("YYGH-USER")  //分类，自定义
                .setExpiration(new Date(System.currentTimeMillis() + tokenExpiration))//设置过期时间
                .claim("userId", userId)//设置主体信息
                .claim("userName", userName)
                .signWith(SignatureAlgorithm.HS512, tokenSignKey)//签名hash
                .compressWith(CompressionCodecs.GZIP)
                .compact();
        return token;
    }

    /**
     * 根据token字符串得到用户的id
     */
    public static Long getUserId(String token) {
        if(StringUtils.isEmpty(token)) return null;
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token);
        Claims claims = claimsJws.getBody();
        Integer userId = (Integer)claims.get("userId");
        return userId.longValue();
    }

    /**
     * 根据token字符串得到用户名
     */
    public static String getUserName(String token) {
        if(StringUtils.isEmpty(token)) return "";
        Jws<Claims> claimsJws
                = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("userName");
    }
}

package com.atguigu.commonutils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * @author helen
 * @since 2019/10/16
 */
public class JwtUtils {

    /**
     * 设置token的过期时间
     */
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    /**
     * 密钥
     */
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO";


    /**
     * 生成token字符串
     */
    public static String getJwtToken(String id, String nickname){

        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("guli-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();

        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断token是否存在与有效
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 根据token获取会员id
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if(StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("id");
    }
}

package com.heima.freemarker;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author Jason Gong
 * @version 1.0
 * @website https://qingling.icu
 * @Date 2023/8/16
 * @Description
 */
@SpringBootApplication
public class FreeMarkerDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(FreeMarkerDemoApplication.class,args);
    }
}

package com.heima.freemarker.entity;

import lombok.Data;

import java.util.Date;

/**
 * @author Jason Gong
 * @version 1.0
 * @website https://qingling.icu
 * @Date 2023/8/16
 * @Description
 */
@Data
public class Student {
    private String name;//姓名
    private int age;//年龄
    private Date birthday;//生日
    private Float money;//钱包
}

package com.heima.freemarker.controller;

import com.heima.freemarker.entity.Student;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * @author Jason Gong
 * @version 1.0
 * @website https://qingling.icu
 * @Date 2023/8/16
 * @Description
 */
@Controller
public class HelloController {

    @GetMapping("/basic")
    public String test(Model model) {
        //1.纯文本形式的参数
        model.addAttribute("name", "freemarker");

        //2.实体类相关的参数
        Student student = new Student();
        student.setName("小明");
        student.setAge(18);
        model.addAttribute("stu", student);

        return "01-basic";
    }
}

@GetMapping("/list")
public String list(Model model){

    //------------------------------------
    Student stu1 = new Student();
    stu1.setName("小强");
    stu1.setAge(18);
    stu1.setMoney(1000.86f);
    stu1.setBirthday(new Date());

    //小红对象模型数据
    Student stu2 = new Student();
    stu2.setName("小红");
    stu2.setMoney(200.1f);
    stu2.setAge(19);

    //将两个对象模型数据存放到List集合中
    List<Student> stus = new ArrayList<>();
    stus.add(stu1);
    stus.add(stu2);

    //向model中存放List集合数据
    model.addAttribute("stus",stus);

    //------------------------------------

    //创建Map数据
    HashMap<String,Student> stuMap = new HashMap<>();
    stuMap.put("stu1",stu1);
    stuMap.put("stu2",stu2);
    // 3.1 向model中存放Map数据
    model.addAttribute("stuMap", stuMap);

    return "02-list";
}

@GetMapping("operation")
public String testOperation(Model model) {
    //构建 Date 数据
    Date now = new Date();
    model.addAttribute("date1", now);
    model.addAttribute("date2", now);
    
    return "03-operation";
}

@GetMapping("innerFunc")
public String testInnerFunc(Model model) {
    //1.1 小强对象模型数据
    Student stu1 = new Student();
    stu1.setName("小强");
    stu1.setAge(18);
    stu1.setMoney(1000.86f);
    stu1.setBirthday(new Date());
    //1.2 小红对象模型数据
    Student stu2 = new Student();
    stu2.setName("小红");
    stu2.setMoney(200.1f);
    stu2.setAge(19);
    //1.3 将两个对象模型数据存放到List集合中
    List<Student> stus = new ArrayList<>();
    stus.add(stu1);
    stus.add(stu2);
    model.addAttribute("stus", stus);
    // 2.1 添加日期
    Date date = new Date();
    model.addAttribute("today", date);
    // 3.1 添加数值
    model.addAttribute("point", 102920122);
    return "04-innerFunc";
}

package com.heima.freemarker.test;

import com.heima.freemarker.FreeMarkerDemoApplication;
import com.heima.freemarker.entity.Student;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Jason Gong
 * @version 1.0
 * @website https://qingling.icu
 * @Date 2023/8/16
 * @Description
 */
@SpringBootTest(classes = FreeMarkerDemoApplication.class)
@RunWith(SpringRunner.class)
public class FreeMarkerTest {
    @Autowired
    //freemarker.template.Configuration
    private Configuration configuration;

    @Test
    public void test() throws IOException, TemplateException {
        Template template = configuration.getTemplate("01-basic.ftl");
        /**
         * 第一个参数:数据模型
         * 第二个参数:输出流
         */
        template.process(getData(),new FileWriter("C:\\Gong\\data\\test.html"));

    }

    /**
     * 构建数据模型
     */
    private Map<String,Object> getData(){
        HashMap<String, Object> map = new HashMap<>();
        //1.纯文本形式的参数
        map.put("name", "freemarker");
        //2.实体类相关的参数
        Student student = new Student();
        student.setName("小明");
        student.setAge(18);
        map.put("stu", student);
        return map;
    }
}

package com.jason;


import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.IOException;
import java.net.URL;

/**
 * @author GongChangjiang
 * @version 1.0
 * @Date 2023/5/9
 * @Description
 */
public class HtmlParseUtil {
    public static void main(String[] args) throws IOException {
        HtmlParseUtil.parseJd("联想电脑");
    }

    /**
     * 爬取京东上的商品数据
     *
     * @param keywords 商品的品牌或者关键字  例如 联想电脑、华为手机、java书籍
     */
    public static void parseJd(String keywords) throws IOException {
        //获取请求
        String url = "https://search.jd.com/Search?keyword=" + keywords;//页面上的地址信息
        //解析网页
        //第一个参数是url地址
        //第二个参数是响应时间,超过30秒就报错
        //返回的document就是浏览器的Document对象
        Document document = Jsoup.parse(new URL(url), 30000);
        //所有在js中可以使用的方法,这里都可以使用
        Element element = document.getElementById("J_goodsList");//通过id获取元素
        //获取所有的li元素
        Elements elements = element.getElementsByTag("li");
        //遍历li元素的集合 获取每一个li元素
        for (Element el : elements) {
            //这种图片特别多的图片 会有一个懒加载
            String attr = el.getElementsByTag("img").eq(0).attr("data-lazy-img");//通过标签获取元素
            String title = el.getElementsByClass("p-name").eq(0).text();//通过class获取元素
            String price = el.getElementsByClass("p-price").eq(0).text();
            System.out.println("图片地址:https:" + attr);
            System.out.println("商品名称:" + title);
            System.out.println("商品价格:" + price);
        }
    }
}

package com.jason;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.IOException;
import java.net.URL;

/**
 * @author GongChangjiang
 * @version 1.0
 * @Date 2023/5/9
 * @Description
 */
public class ParseHouse {
    public static void main(String[] args) throws IOException {
        //爬起房天下上面的房源数据
        int i = 91;
        while (true){//换页读取   页面有分页条的情况
            String url = "https://newhouse.fang.com/house/s/b"+i;
            System.out.println("正在爬取第"+i+"页的数据.....");
            ParseHouse.selectHouses(url);
            i++;
        }

    }

    public static void selectHouses(String url) throws IOException {
        Document document = Jsoup.parse(new URL(url), 30000);
        Element element = document.getElementById("newhouse_loupan_list");
        Elements elements = element.getElementsByTag("li");
        for (Element el : elements) {
            String images = el.getElementsByTag("img").eq(1).attr("src");
            String alt = el.getElementsByTag("img").eq(1).attr("alt");
            String price = el.getElementsByClass("nhouse_price").text();
            System.out.println("图片:https:"+images);
            System.out.println("名称:"+alt);
            System.out.println("房价:"+price);
        }
    }
}

package com.jason;

import com.alibaba.excel.EasyExcel;
import com.jason.entity.HorseInfo;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * @author GongChangjiang
 * @version 1.0
 * @Date 2023/5/9
 * @Description  爬取全国各地房价的信息到excel表格中
 */
public class HousePriseList {
    public static void main(String[] args) throws IOException {
        //爬取全国房价排行榜
        String fileName = "C:\\AlYun\\work\\housePriceList.xlsx";
        //通过下面的中间表，我们可以实现向excel中追加数据 不是每次删除之前的数据再写入 或者追加的时候有多个表头信息
        String temp = "C:\\AlYun\\work\\temp.xlsx"; //中间表 会自动被删除
        int i = 1;
        while (true) {
            try {
                String url = "https://fangjia.gotohui.com/top/" + i + ".html";
                List<HorseInfo> horseInfos = HousePriseList.selectHorse(url);
                File file = new File(fileName);
                File tempFile = new File(temp);
                if (file.exists()) {  //判断excel表中是否写入过数据  写入过数据就追加数据
                    // 第二次按照原有格式，不需要表头，追加写入
                    EasyExcel.write(file, HorseInfo.class).needHead(false).
                            withTemplate(file).file(tempFile).sheet().doWrite(horseInfos);
                } else {
                    // 第一次写入需要表头
                    EasyExcel.write(file, HorseInfo.class).sheet().doWrite(horseInfos);
                }
                if (tempFile.exists()) {
                    file.delete();
                    tempFile.renameTo(file);
                }
                i++;
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
                break;
            }
        }
    }

    public static List<HorseInfo> selectHorse(String url) throws IOException {
        Document document = Jsoup.parse(new URL(url), 30000);
        Elements elements = document.getElementsByClass("ntable table-striped table-hover");
        ArrayList<HorseInfo> horseInfos = new ArrayList<>();
        for (Element element : elements) {
            Elements tr = element.getElementsByTag("tr");
            for (Element el : tr) {
                Elements td = el.getElementsByTag("td");
                System.out.println("-----------------------------------------");
                System.out.println("编号:" + td.eq(0).text());
                System.out.println("城市:" + td.eq(1).text());
                System.out.println("单价(元/㎡):" + td.eq(2).text());
                System.out.println("同比(去年):" + td.eq(3).text());
                System.out.println("环比(上月):" + td.eq(4).text());
                System.out.println("收入比:" + td.eq(5).text());
                if (!td.eq(0).text().equals("")) {
                    horseInfos.add(new HorseInfo(
                            td.eq(0).text(),
                            td.eq(1).text(),
                            td.eq(2).text(),
                            td.eq(3).text(),
                            td.eq(4).text(),
                            td.eq(5).text()
                    ));
                }

            }
        }
        return horseInfos;
    }
}

@Controller
public class CodeController {

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

package com.mine.code.controller;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.aztec.encoder.AztecCode;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Jason Gong
 * @version 1.0
 * @website https://qingling.icu
 * @Date 2023/8/28
 * @Description
 */
@Slf4j
@Controller
public class CodeController {

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


    @GetMapping("/generate")
    public String generate(@RequestParam("url") String url, HttpServletResponse response) {
        log.info("文本内容:{}", url);
        try {
            //创建一个map集合，存储二维码的相关属性
            Map map = new HashMap<>();
            //EncodeHintType 编码的提示类型
            //设置二维码的误差校正级别 可选值有 L(7%) M(15%) Q(25%) H(30%)
            //选择L级别的容错率，相当于允许二维码在整体的颜色区域中，最多有7%的坏像素点;择H级别的容错率，相当于允许二维码在整体的颜色区域中，最多有30%的坏像素点
            map.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
            //设置二维码的字符集
            map.put(EncodeHintType.CHARACTER_SET, "utf-8");
            //设置二维码四周的留白 1表示1像素
            map.put(EncodeHintType.MARGIN, 1);
            //创建zxing的核心对象MultiFormatWriter (多格式写入器)
            //通过MultiFormatWriter对象来生成二维码
            MultiFormatWriter writer = new MultiFormatWriter();
            //参数一:内容
            //参数二:二维码格式
            //BarcodeFormat(码格式) QR_CODE ：常见的二维码格式之一，广泛应用于商品包装、扫码支付
            //AZTEC_CODE：高密度，可靠性很高 容错率更低 储存个人信息、证件信息、账户密码
            //PDF417 可以存储大量的信息 数据密度高 应用于航空机票、配送标签、法律文件
            //DATA_MATRIX: 小巧的二维码格式 编码格式类似于QR_CODE 但是优于QR_CODE 适合嵌入简单的产品标签 医疗图像 检测数据
            //参数三四:二维码的宽度和高度
            //参数五:二维码参数
            //位矩阵对象 （位矩阵对象对象的内部实际上是一个二位数组，二维数组中每一个元素是boolean类型 true代表黑色 false代表白色）
            BitMatrix bitMatrix = writer.encode(url, BarcodeFormat.QR_CODE, 300, 300, map);
            //获取矩阵的宽度和高度
            int width = bitMatrix.getWidth();
            int height = bitMatrix.getHeight();
            //生成二维码图片
            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
            //遍历位矩阵对象
            for (int x = 0; x < width; x++) {
                for (int y = 0; y < height; y++) {
                    //设置每一块的颜色值
                    //0xFF000000表示黑色  0xFFFFFFFF表示白色
                    image.setRGB(x, y, bitMatrix.get(x, y) ? 0xFF000000 : 0xFFFFFFFF);
                }
            }
            //将图片响应到客户端
            ServletOutputStream out = response.getOutputStream();
            ImageIO.write(image,"png",out);
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

/**
     * 跳转到生成带logo的黑白二维码
     */
@GetMapping("/logo")
public String toLogo() {
    return "qrcode";
}

/**
     * 生成带logo的黑白二维码
     */
@PostMapping("/generateWithLogo")
public String generateWithLogo(@RequestParam("url") String url, HttpServletResponse response, HttpServletRequest request) {
    try {
        Map map = new HashMap<>();
        map.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
        map.put(EncodeHintType.CHARACTER_SET, "utf-8");
        map.put(EncodeHintType.MARGIN, 1);
        MultiFormatWriter writer = new MultiFormatWriter();
        BitMatrix bitMatrix = writer.encode(url, BarcodeFormat.QR_CODE, 300, 300, map);
        int width = bitMatrix.getWidth();
        int height = bitMatrix.getHeight();
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                image.setRGB(x, y, bitMatrix.get(x, y) ? 0xFF000000 : 0xFFFFFFFF);
            }
        }
        //给二维码添加logo
        //1.获取logo
        Part logoPart = request.getPart("logo");
        InputStream inputStream = logoPart.getInputStream();
        BufferedImage logoImage = ImageIO.read(inputStream);
        //2.对获取的logo图片进行缩放
        int logoWidth = logoImage.getWidth(null);
        int logoHeight = logoImage.getHeight(null);
        if (logoWidth > 60){
            logoWidth = 60;
        }
        if (logoHeight > 60){
            logoHeight = 60;
        }
        //使用平滑缩放算法对原始的logo图像进行缩放到一个全新的图像
        Image scaledLogo = logoImage.getScaledInstance(logoWidth, logoHeight, Image.SCALE_SMOOTH);
        //3.将缩放的图片画在黑白的二维码上
        //获取一个画笔
        Graphics2D graphics2D = image.createGraphics();
        //计算从哪里开始画 300指的是二维码的宽度和高度
        int x = (300 - logoWidth) /2;
        int y = (300 - logoHeight) /2;
        //画上去
        graphics2D.drawImage(scaledLogo,x,y,null);
        //实现logo的圆角效果
        Shape shape = new RoundRectangle2D.Float(x, y, logoWidth, logoHeight, 10, 10);
        //使用一个宽度为4像素的基本笔触
        graphics2D.setStroke(new BasicStroke(4f));
        //给logo画圆角矩形
        graphics2D.draw(shape);
        //释放画笔
        graphics2D.dispose();
        //将二维码响应到浏览器
        ImageIO.write(image, "png", response.getOutputStream());
        //关闭流
        inputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}