史上最详细《学成在线》项目实操笔记系列【下】，跟视频的每一P对应，全系列18万字，涵盖详细步骤与问题的解决方案。如果你操作到某一步卡壳，参考这篇，相信会带给你极大启发。
四、课程发布模块
4.1 (课程发布)模块需求 P92
课程预览：在发布课程之前需要预览一下，看最终的效果有没有问题，课程信息是否完整。
课程审核：预览之后就是运营人员进行审核，审核分为程序自动审核和人工审核。
课程发布：发布之后课程可以被搜索到。
4.2 (课程发布)freemarker P93
freemarker是模板引擎。
在xuecheng-plus-content的xuecheng-plus-content-api的pom.xml下新增依赖：
<!-- Spring Boot 对结果视图 Freemarker 集成 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
在nacos的freemarker-config-dev.yaml中写入如下代码：
在xuecheng-plus-content-api下进行如下配置：
在xuecheng-plus-content的xuecheng-plus-content-api的api下创建FreemarkerController中写入如下代码：
@Slf4j
@RestController
public class FreemarkerController {
@GetMapping("/testfreemarker")
public ModelAndView test(){
ModelAndView modelAndView = new ModelAndView();
//指定模型
modelAndView.addObject("name","小明");
//指定模板
modelAndView.setViewName("test");//根据视图名称加.ftl找到模板
return modelAndView;
}
}
测试没啥问题：
4.3 (课程发布)部署门户 P94
静态资源一般部署到nginx上。
首先解压nginx文件，配置文件位置如下：
啥也不配置直接启动，效果如下：
windows本地机hosts文件地址如下：C:\Windows\System32\drivers\etc，写入如下配置
127.0.0.1 www.51xuecheng.cn 51xuecheng.cn ucenter.51xuecheng.cn teacher.51xuecheng.cn file.51xuecheng.cn
在server_name中写入如下门户地址：
完整的配置如下：
server {
listen 80;
server_name www.51xuecheng.cn localhost;
#rewrite ^(.*) https://$server_name$1 permanent;
#charset koi8-r;
ssi on;
ssi_silent_errors on;
#access_log logs/host.access.log main;
location / {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/;
index index.html index.htm;
}
#静态资源
location /static/img/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/img/;
}
location /static/css/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/css/;
}
location /static/js/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/js/;
}
location /static/plugins/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/plugins/;
add_header Access-Control-Allow-Origin http://ucenter.51xuecheng.cn;
add_header Access-Control-Allow-Credentials true;
add_header Access-Control-Allow-Methods GET;
}
location /plugins/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/plugins/;
}
}
保存之后， 2种方法让配置生效，方法1：ctrl+shift+esc直接把任务停掉。方法2：nginx.exe -s reload。可以看到显示没有任何问题：
课程详情页面能正常浏览：
记得下面weight=10后面有一个分号;
upstream fileserver{
server 192.168.101.65:9000 weight=10;
}
server {
listen 80;
server_name file.51xuecheng.cn;
#charset koi8-r;
ssi on;
ssi_silent_errors on;
#access_log logs/host.access.log main;
location /video {
proxy_pass http://fileserver;
}
location /mediafiles {
proxy_pass http://fileserver;
}
}
效果如下：
下面测试一下：
http://file.51xuecheng.cn/mediafiles/2022/09/13/a16da7a132559daf9e1193166b3e7f52.jpg
最后想要视频能够播放，添加如下配置：
location /course/preview/learning.html {
alias D:/itcast2022/xc_edu3.0/code_1/xc-ui-pc-static-portal/course/learning.html;
}
location /course/search.html {
root D:/itcast2022/xc_edu3.0/code_1/xc-ui-pc-static-portal;
}
location /course/learning.html {
root D:/itcast2022/xc_edu3.0/code_1/xc-ui-pc-static-portal;
}
进入到播放详情页面：
http://www.51xuecheng.cn/course/course_template.html
搜索videoObject，然后找到video对应的url链接，填写minio上视频的链接。
经测试视频播放没有问题：
完整配置如下：
worker_processes 1;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
upstream fileserver{
server 192.168.101.65:9000 weight=10;
}
server {
listen 80;
server_name file.51xuecheng.cn;
ssi on;
ssi_silent_errors on;
location /video {
proxy_pass http://fileserver;
}
location /mediafiles {
proxy_pass http://fileserver;
}
}
server {
listen 80;
server_name www.51xuecheng.cn localhost;
ssi on;
ssi_silent_errors on;
location / {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/;
index index.html index.htm;
}
location /static/img/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/img/;
}
location /static/css/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/css/;
}
location /static/js/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/js/;
}
location /static/plugins/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/plugins/;
add_header Access-Control-Allow-Origin http://ucenter.51xuecheng.cn;
add_header Access-Control-Allow-Credentials true;
add_header Access-Control-Allow-Methods GET;
}
location /plugins/ {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/plugins/;
}
location /course/preview/learning.html {
alias C:/xuechengzaixian/xc-ui-pc-static-portal/course/learning.html;
}
location /course/search.html {
root C:/xuechengzaixian/xc-ui-pc-static-portal;
}
location /course/learning.html {
root C:/xuechengzaixian/xc-ui-pc-static-portal;
}
}
}
4.4 (课程预览)接口开发 P95
把course_template.html（这里面都是写死的数据）拷贝到xuecheng-plus-content-api的resources的templates下，改后缀名为course_template.ftl：
在xuecheng-plus-content-api的api下创建CoursePublishController，写入如下代码：
@Controller
public class CoursePublishController {
@Autowired
CoursePublishService coursePublishService;
@GetMapping("/coursepreview/{courseId}")
public ModelAndView preview(@PathVariable("courseId")Long courseId){
ModelAndView modelAndView = new ModelAndView();
//查询课程的信息作为模板数据
CoursePreviewDto coursePreviewDto = coursePublishService.getCoursePreviewInfo(courseId);
modelAndView.addObject("model",coursePreviewDto);
modelAndView.setViewName("course_template");
return modelAndView;
}
}
注解@Controller响应页面，@RestController响应json
启动content后，访问下面连接：
http://localhost:63040/content/coursepreview/12
会出现下面界面：
css页面在nginx里面，现在可以直接在nginx中配置经过网关。
-
代码如下（千万记得在gatewayserver后面还要加上一个/）：
upstream gatewayserver{
server 127.0.0.1:63010 weight=10;
}
#api
location /api/ {
proxy_pass http://gatewayserver/;
}
解析：比如现在我输入：www.51xuecheng.cn/api/content/coursepreview/12，nginx会将www.51xuecheng.cn/api/，解析成http://127.0.0.1:63010/，然后把content/coursepreview/12拼接到解析后的访问前缀中，http://127.0.0.1:63010/content/coursepreview/12。
输入url，先到nginx，然后到网关，最后到微服务。
在xuecheng-plus-content-model下面创建CoursePreviewDto，然后写入如下代码：
@Data
public class CoursePreviewDto {
//课程基本信息，营销信息
private CourseBaseInfoDto courseBase;
//课程计划信息
private List<TeachplanDto> teachplans;
//课程师资信息..
}
在xuecheng-plus-content-service的service下面创建CoursePublishService：
//课程发布相关接口
public interface CoursePublishService {
/**
* @param courseId 课程id
* @return
*/
public CoursePreviewDto getCoursePreviewInfo(Long courseId);
}
在xuecheng-plus-content-service的service的impl下面创建CoursePublishServiceImpl，写入如下代码：
//课程发布相关接口实现
@Slf4j
@Service
public class CoursePublishServiceImpl implements CoursePublishService {
@Autowired
CourseBaseInfoService courseBaseInfoService;
@Autowired
TeachplanService teachplanService;
@Override
public CoursePreviewDto getCoursePreviewInfo(Long courseId) {
CoursePreviewDto coursePreviewDto = new CoursePreviewDto();
//课程基本信息，营销信息
CourseBaseInfoDto courseBaseInfo = courseBaseInfoService.getCourseBaseInfo(courseId);
//课程计划信息
List<TeachplanDto> teachplanTree = teachplanService.findTeachplanTree(courseId);
coursePreviewDto.setTeachplans(teachplanTree);
return coursePreviewDto;
}
}
前端放开下面的服务网关端口，启动下面3个服务：
访问下面的地址：
http://localhost:8601/
在IDEA中打上断点，点击预览按钮， 然后看看取得的数据是不是完整正确的
上一步只是获取到数据，下一步开始在页面中动态展示。
更改完模板之后，可以选择build下面的recompile进行重新编译。
举例修改下面2个地方：
有一个现成的course_template.ftl文件
这里要记得修改27行的下面这个地方：
在nginx中配置如下，主要是为了看视频和目录：
/content/open/主要为了显示目录，/media/open/主要为了显示视频资源。
在xuecheng-plus-content-api的api下面创建CourseOpenController类，写入如下代码：
@Api(value = "课程公开查询接口",tags = "课程公开查询接口")
@RestController
@RequestMapping("/open")
public class CourseOpenController {
@Autowired
private CourseBaseInfoService courseBaseInfoService;
@Autowired
private CoursePublishService coursePublishService;
@GetMapping("/course/whole/{courseId}")
public CoursePreviewDto getPreviewInfo(@PathVariable("courseId") Long courseId) {
//获取课程预览信息
CoursePreviewDto coursePreviewInfo = coursePublishService.getCoursePreviewInfo(courseId);
return coursePreviewInfo;
}
}
在xuecheng-plus-media-api的api下面创建MediaOpenController类，写入如下代码：
@Api(value = "媒资文件管理接口",tags = "媒资文件管理接口")
@RestController
@RequestMapping("/open")
public class MediaOpenController {
@Autowired
MediaFileService mediaFileService;
@ApiOperation("预览文件")
@GetMapping("/preview/{mediaId}")
public RestResponse<String> getPlayUrlByMediaId(@PathVariable String mediaId){
MediaFiles mediaFiles = mediaFileService.getFileById(mediaId);
if (mediaFiles==null) {
return RestResponse.validfail("找不到视频");
}
String url = mediaFiles.getUrl();
if (StringUtils.isEmpty(url)) {
return RestResponse.validfail("该视频正在处理中");
}
return RestResponse.success(mediaFiles.getUrl());
}
}
启动下面4个服务：
测试如下，视频可以正常播放：
4.5 提交课程审核 P96
在course_base表中设置课程审核状态字段，包括：未提交、已提交、审核通过、审核不通过。
只有审核通过才能够发布。只有未提交和审核不通过才能到已提交状态。
但是要注意教学机构可以在审核状态中修改部分信息，但是在运营人员正在审核时教学机构不能修改信息（可以新建一个副本）。
如上图建一个预发布表，集成了课程营销信息、课程师资、课程基本信息、课程计划这几张表。
审核审的是预发布表，修改修改的是左边的4张表。
如果可以发布，就是把预发布表的拷贝到发布表。
如果审核人员正在审核预发布表，则教育机构不能提交审核。
信息组合可以直接以json串的格式传入：
对提交的约束如下：
在xuecheng-plus-content-service的service下创建CoursePublishService中写入如下代码：
public void commitAudit(Long companyId,Long courseId);
在xuecheng-plus-content-service的service下的CoursePublishServiceImpl下写入如下代码：
@Override
public void commitAudit(Long companyId, Long courseId) {
CourseBaseInfoDto courseBaseInfo = courseBaseInfoService.getCourseBaseInfo(courseId);
if(courseBaseInfo == null){
XueChengPlusException.cast("课程找不到");
}
//审核状态
String auditStatus = courseBaseInfo.getAuditStatus();
//如果课程的审核状态为已提交则不允许提交
if(auditStatus.equals("202003")){
XueChengPlusException.cast("课程已提交请等待审核");
}
//课程的图片、计划信息没有填写也不允许提交
String pic = courseBaseInfo.getPic();
if(StringUtils.isEmpty(pic)){
XueChengPlusException.cast("请求上传课程图片");
}
//查询课程计划
//课程计划信息
List<TeachplanDto> teachplanTree = teachplanService.findTeachplanTree(courseId);
if(teachplanTree==null || teachplanTree.size()==0){
XueChengPlusException.cast("请编写课程计划");
}
//查询到课程基本信息、营销信息。计划等信息插入到课程预发布表
CoursePublishPre coursePublishPre = new CoursePublishPre();
BeanUtils.copyProperties(courseBaseInfo,coursePublishPre);
//营销信息
CourseMarket courseMarket = courseMarketMapper.selectById(courseId);
//转JSON
String courseMarketJson = JSON.toJSONString(courseMarket);
coursePublishPre.setMarket(courseMarketJson);
//计划信息
//转json
String teachplanTreeJson = JSON.toJSONString(teachplanTree);
coursePublishPre.setTeachplan(teachplanTreeJson);
//状态为已提交
coursePublishPre.setStatus("202003");
//提交时间
coursePublishPre.setCreateDate(LocalDateTime.now());
//查询预发布表，如果有记录则更新，没有则插入
CoursePublishPre coursePublishPreObj = coursePublishPreMapper.selectById(courseId);
if(coursePublishPreObj==null){
//插入
coursePublishPreMapper.insert(coursePublishPre);
}else{
//更新
coursePublishPreMapper.updateById(coursePublishPre);
}
//更新课程基本信息表的审核状态为已提交
CourseBase courseBase = courseBaseMapper.selectById(courseId);
courseBase.setAuditStatus("202003");//审核状态为已提交
courseBaseMapper.updateById(courseBase);
}
记得在xuecheng-plus-content-service下的CourseBaseInfoServiceImpl的getCourseBaseInfo方法下写入如下代码：
CourseCategory mtObj = courseCategoryMapper.selectById(courseBase.getMt());
String mtName = mtObj.getName();//大分类名称
courseBaseInfoDto.setMtName(mtName);
CourseCategory stObj = courseCategoryMapper.selectById(courseBase.getSt());
String stName = stObj.getName();//小分类名称
courseBaseInfoDto.setStName(stName);
重启content模块，测试：
如果提交审核失败，页面上端会显示失败的原因。
如果提交审核成功，会在content数据库的course_publish_pre表里面看到这条记录。
首先更改预发布表的状态为审核通过
然后更改课程基本信息表
4.6 (课程发布)需求分析 P97
发布之后课程信息的网页是能够众多网民看的，如果存储在数据库中，可能导致性能低下。
课程的信息要插入到Elasticsearch中，把课程信息缓存到Redis中。生成的课程静态页面（html文件）上传到minio中。
4.7 什么是分布式事务 P98
本地事务（使用服务自己的数据库来控制事务）是spring利用数据库本身的事务特性去控制事务。本地事务具有CAID四大特性，会将事务纳入一个不可分割的执行单元。
分布式事务（特点是涉及到多个服务来执行同一件事。分布式系统之间要完成一件事，服务之间还要通过远程调用交互）
分布式事务例子：
微服务架构，比如下订单后调用库存服务减库存：
单服务多数据库：
多服务单数据库：
4.8 什么是CAP理论 P99
CAP是Consistency、Availability、Partition tolerance，即一致性、可用性、分区容忍性的缩写。
一致性：用户不管访问哪个结点拿到的数据都是最新的，比如查询小明的信息，不能出现在数据库没有改变情况下两次查询结果不一样。
可用性：指任何时候查询用户信息都可以查询到结果，但不保证查询到最新的数据。
分区容忍性：也叫分区容错性，当系统采用分布式架构时由于网络通信异常导致请求中断、消息丢失，但系统依然对外提供服务。
A和C不能同时满足，要么满足AP（强调可用性）要么满足CP（一致性）。
比如用户把自己的名字"小明"上传到服务节点1。如果要保证一致性，只有当服务节点1中的数据同步到服务节点2中系统才可用。如果要保证可用性，就不能等待信息同步完成，在同步过程中也能使用。
银行转账一定保证CP。
但现实生活中一般AP的场景比较多。所以提出了BASE理论。
BASE是Basically Available(基本可用)，Soft State(软状态)和Eventuallyconsistent(最终一致性)。
基本可用：比如在订单高峰的时候，只要支付能用即可。
软状态：有一个中间状态，比如运输中...支付中...
最终一致性：最终的数据要一致。
实现AP保证数据最终一致性：
使用消息队列：如失败自动充实，达到最大失败次数人工处理。
使用任务调度的方案：启动任务调度将课程信息由数据库同步到Elasticsearch、Minio、redis中。
4.9 分布式事务控制方案 P100
现在可以新建一张消息表，现在可以在该表中标记一个字段值表示为要发布的课程，然后任务调度中心去调度服务，把信息同步到redis、Elasticsearch和minio中。写完之后把数据删掉
本地消息表+任务调度的机制来完成分布式事务的最终事务一致性的控制。
course_publish和mq_message表是在同一个数据库，可以使用数据库事务来控制
任务调度程序可以读取mq_message的数据，然后同步到redis，Elasticsearch和minio中。
现在假如redis挂掉了怎么办呢？无数轮也没用了。程序自动运维，监管系统网管系统告警系统，运维人员收到告警远程处理或者去现场处理。
4.10 (课程发布)发布接口P101
在xuecheng-plus-content-api的api的CoursePublishController下写入代码：
在xuecheng-plus-content-service的service的CoursePublishService下写入代码：
在xuecheng-plus-content-service的service的impl的CoursePublishServiceImpl下写入代码：
4.11 (课程发布)消息sdk P102
在第8天资料中，解压出下面文件xuecheng-plus-message-sdk：
把工具包拷贝到工程目录中，设置为maven工程：
在xuecheng-plus-content-service下的pom.xml文件中写入依赖：
<dependency>
<groupId>com.xuecheng</groupId>
<artifactId>xuecheng-plus-message-sdk</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
在xuecheng-plus-content-api的api的CoursePublishController下写入代码：
@ApiOperation("课程发布")
@ResponseBody
@PostMapping("/coursepublish/{courseId}")
public void coursepublish(@PathVariable("courseId") Long courseId){
Long companyId = 1232141425L;
coursePublishService.publish(companyId,courseId);
}
在xuecheng-plus-content-service的service的CoursePublishService下写入代码：
public void publish(Long companyId,Long courseId);
在xuecheng-plus-content-service的service的impl的CoursePublishServiceImpl下写入代码：
@Autowired
CoursePublishMapper coursePublishMapper;
@Autowired
MqMessageService mqMessageService;
@Transactional
@Override
public void publish(Long companyId, Long courseId) {
//查询预发布表
CoursePublishPre coursePublishPre = coursePublishPreMapper.selectById(courseId);
if(coursePublishPre==null){
XueChengPlusException.cast("课程没有审核记录，无法发布");
}
//状态
String status = coursePublishPre.getStatus();
//课程如果没有审核通过不允许发布
if(!status.equals("202004")){
XueChengPlusException.cast("课程没有审核通过不允许发布");
}
//向课程发布表写入数据
CoursePublish coursePublish = new CoursePublish();
BeanUtils.copyProperties(coursePublishPre,coursePublish);
//先查询课程发布表，有则更新,没有再添加
CoursePublish coursePublishObj = coursePublishMapper.selectById(courseId);
if(coursePublishObj==null){
coursePublishMapper.insert(coursePublish);
}else{
coursePublishMapper.updateById(coursePublish);
}
//向消息表写入数据
MqMessage mqMessage = mqMessageService.addMessage("course_publish", String.valueOf(courseId), null, null);
if(mqMessage==null){
XueChengPlusException.cast(CommonError.UNKOWN_ERROR);
}
//将预发布表数据删除
coursePublishPreMapper.deleteById(courseId);
}
启动contentApplication和gatewayApplication和systemApplication，记得启动nginx和前端，进行前后端联调。
在预发布表course_publish_pre已有一条数据，改为202004
course_base那条数据也改为202004，记得是在audit_status这个字段进行修改：
进入前端，找到之前那条已经审核通过的，然后点击发布，在课程发布表可以看到course_publish，在mq_message也可以看到记录，
4.12 (课程发布)课程发布任务调度 P103
在xuecheng-plus-content-service的service下面创建jobhandler包，然后创建一个CoursePublishTask类，写入如下代码：
在xuecheng-plus-content-service的pom.xml下面写入依赖：
<dependency>
<groupId>com.xuxueli</groupId>
<artifactId>xxl-job-core</artifactId>
</dependency>
在content-service-dev.yaml配置文件中进行配置：
xxl:
job:
admin:
addresses: http://192.168.101.65:8088/xxl-job-admin
executor:
appname: coursepublish-job
address:
ip:
port: 8999
logpath: /data/applogs/xxl-job/jobhandler
logretentiondays: 30
accessToken: default_token
把XxlJobConfig拷贝到xuecheng-plus-content-service的config下面：
执行器coursepublish-job
在任务管理-课程发布任务执行器新建下面的任务，记得启动：
要在下面这个地方打上断点：
4.13 (课程发布)页面静态化P104
原理：因为静态页面可以使用nginx（每秒大约5万并发），apache等高性能的web服务器，并发性能高。
页面静态化：将生产html页面过程提前，提前使用模板引擎技术生成html页面，客户端可以直接请求到html页面。
用页面静态化技术的时机：当数据不频繁变化。因为课程发布后仍能修改，但需要经过课程审核。
在xuecheng-plus-content-service中添加如下依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
在xuecheng-plus-content-service的test下创建FreemarkerTest，写入如下测试代码（这里我是把classpath写死了，老师的写法会报错，可能是因为路径上有中文的缘故吧）：
@SpringBootTest
public class FreemarkerTests {
@Autowired
CoursePublishService coursePublishService;
//测试页面静态化
@Test
public void testGenerateHtmlByTemplate() throws IOException, TemplateException {
//配置freemarker
Configuration configuration = new Configuration(Configuration.getVersion());
//加载模板
//选指定模板路径,classpath下templates下
//得到classpath路径
//String classpath = this.getClass().getResource("/").getPath();
String classpath = "C:\\xuechengzaixian\\xuecheng-plus-project\\xuecheng-plus-content\\xuecheng-plus-content-service\\target\\test-classes";
configuration.setDirectoryForTemplateLoading(new File(classpath + "/templates/"));
//设置字符编码
configuration.setDefaultEncoding("utf-8");
//指定模板文件名称
Template template = configuration.getTemplate("course_template.ftl");
//准备数据
CoursePreviewDto coursePreviewInfo = coursePublishService.getCoursePreviewInfo(2L);
Map<String, Object> map = new HashMap<>();
map.put("model", coursePreviewInfo);
//静态化
//参数1：模板，参数2：数据模型
String content = FreeMarkerTemplateUtils.processTemplateIntoString(template, map);
System.out.println(content);
//将静态化内容输出到文件中
InputStream inputStream = IOUtils.toInputStream(content);
//输出流
FileOutputStream outputStream = new FileOutputStream("C:\\software\\test.html");
IOUtils.copy(inputStream, outputStream);
}
}
因为微服务各个服务之间是各司其职的，现在媒资服务是专门负责上传的，现在如果想把生成的静态文件上传到minio，需要Feign。
在xuecheng-plus-content-service的pom.xml文件中写入如下代码：
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- Spring Cloud 微服务远程调用 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-httpclient</artifactId>
</dependency>
<!--feign支持Multipart格式传参-->
<dependency>
<groupId>io.github.openfeign.form</groupId>
<artifactId>feign-form</artifactId>
<version>3.8.0</version>
</dependency>
<dependency>
<groupId>io.github.openfeign.form</groupId>
<artifactId>feign-form-spring</artifactId>
<version>3.8.0</version>
</dependency>
把如下的代码写入到nacos的feign-dev.yaml中：
feign:
hystrix:
enabled: true
circuitbreaker:
enabled: true
hystrix:
command:
default:
execution:
isolation:
thread:
timeoutInMilliseconds: 30000 #熔断超时时间
ribbon:
ConnectTimeout: 60000 #连接超时时间
ReadTimeout: 60000 #读超时时间
MaxAutoRetries: 0 #重试次数
MaxAutoRetriesNextServer: 1 #切换实例的重试次数
拷贝MultipartSupportConfig到xuecheng-plus-content-service的config下
在xuecheng-plus-content-api和service的test的配置文件中，都引入下面的配置文件：
shared-configs:
- data-id: feign-${spring.profiles.active}.yaml
group: xuecheng-plus-common
refresh: true
在MediaFileService和MediaFileServiceImpl的uploadFile方法中添加一个参数：String objectName。
4.14 (课程发布)熔断降级 P105
现在是内容管理服务调用媒资管理服务。
spring会生成一个代理对象，在代理对象中去实现远程调用。
@FeignClient(value="media-api")用FeignClient注解来指定属于哪个服务，比如媒资服务。
在xuecheng-plus-content-service的content的feignclient下创建MediaServiceClient，写入如下代码：
//远程调用媒资服务的接口
@FeignClient(value="media-api",configuration = {MultipartSupportConfig.class})
public interface MediaServiceClient {
@RequestMapping(value="/media/upload/coursefile",consumes= MediaType.MULTIPART_FORM_DATA)
public String upload(@RequestPart("filedata")MultipartFile filedata,
@RequestParam(value="objectName",required = false)String objectName);
}
在xuecheng-plus-content-service的test下的content下创建FeignUploadTest，写入如下代码：
@SpringBootTest
public class FeignUploadTest {
@Autowired
MediaServiceClient mediaServiceClient;
@Test
public void test() {
//将file转MultipartFile
File file = new File("C:\\software\\test.html");
MultipartFile multipartFile = MultipartSupportConfig.getMultipartFile(file);
mediaServiceClient.upload(multipartFile,"course/test.html");
}
}
在xuecheng-plus-content-service的test下的ContentApplication的类上加入如下注解：
@EnableFeignClients(basePackages={"com.xuecheng.content.feignclient"})
现在出现的是下面这个问题：
需要加入下面蓝色区域的代码：
可以看到minio中的mediafiles下的course目录下有了test.html文件：
可以通过下面的链接查看上传的文件，其中test.html要替换为你自己的文件名
http://192.168.101.65:9000/mediafiles/course/test.html
但没有基本的样式：
在nginx的配置文件中，找到server_name为www.51xuecheng.cn localhost的server配置，然后在其下添加如下配置：
访问下面这个页面：
http://www.51xuecheng.cn/course/test.html
效果如下：
feign远程调用涉及熔断。
微服务雪崩：如果A调B，B调C，假如此时C服务出现问题，此时A和B都会出现问题。
内容管理服务（上游服务）要调用媒资管理服务（下游服务）。
熔断是下游服务异常时一种保护系统的手段。降级是熔断后上游服务处理熔断的方法。
方法1：使用fallback来定义降级的类，无法拿到熔断降级的具体诱因。
方法2：使用fallbackFactory，定义一个MediaServiceClientFallbackFactory继承FallbackFactory<T>，这个T泛型写的是MediaServiceClient这个类。可以拿到熔断的异常信息。
在xuecheng-plus-content-service的feignclient包的MediaServiceClient接口下面，主要完善@FeignClient注解：
@FeignClient(value="media-api",configuration = MultipartSupportConfig.class,fallbackFactory = MediaServiceClientFallbackFactory.class)
在xuecheng-plus-content-service的feignclient包的MediaServiceClientFallbackFactory接口下面写入如下代码：
@Component
@Slf4j
public class MediaServiceClientFallbackFactory implements FallbackFactory<MediaServiceClient> {
//拿到了熔断的异常信息throwable
@Override
public MediaServiceClient create(Throwable throwable) {
return new MediaServiceClient() {
//发生熔断上传服务调用此方法执行降级逻辑
@Override
public String upload(MultipartFile filedata, String objectName) {
log.debug("远程调用上传文件的接口发生熔断:{}",throwable.toString(),throwable);
return null;
}
};
}
}
结构如下：
我的xuecheng-plus-content-service的test很奇怪没办法识别到nacos的配置，所以我单独在test的resources的bootstrap.yml中写入如下配置代码：
feign:
hystrix:
enabled: true
circuitbreaker:
enabled: true
hystrix:
command:
default:
execution:
isolation:
thread:
timeoutInMilliseconds: 30000 #熔断超时时间
ribbon:
ConnectTimeout: 60000 #连接超时时间
ReadTimeout: 60000 #读超时时间
MaxAutoRetries: 0 #重试次数
MaxAutoRetriesNextServer: 1 #切换实例的重试次数
测试：首先停掉媒资服务，可以把所有服务都停掉，然后在return null上打断点，如果进入到return null即表示降级成功。
熔断：下游服务出现问题触发熔断。
4.15 (课程发布)页面静态化任务 P106
在xuecheng-plus-content-service的service的CoursePublishService下新增2个方法的声明：
//课程静态化
public File generateCourseHtml(Long courseId);
//上传课程静态化页面
public void uploadCourseHtml(Long courseId,File file);
在xuecheng-plus-content-service的service的impl的CoursePublishServiceImpl下写入2个方法的实现代码：
@Autowired
CoursePublishService coursePublishService;
@Override
public File generateCourseHtml(Long courseId) {
//配置freemarker,加载模板
Configuration configuration = new Configuration(Configuration.getVersion());
//最终的静态文件
File htmlFile = null;
try{
//得到classpath路径
String classpath = this.getClass().getResource("/").getPath();
//选指定模板路径,classpath下templates下
configuration.setDirectoryForTemplateLoading(new File(classpath + "/templates/"));
//设置字符编码
configuration.setDefaultEncoding("utf-8");
//指定模板文件名称
Template template = configuration.getTemplate("course_template.ftl");
//准备数据
CoursePreviewDto coursePreviewInfo = this.coursePublishService.getCoursePreviewInfo(courseId);
Map<String, Object> map = new HashMap<>();
map.put("model", coursePreviewInfo);
//静态化
//参数1：模板，参数2：数据模型
String html = FreeMarkerTemplateUtils.processTemplateIntoString(template, map);
//输入流
InputStream inputStream = IOUtils.toInputStream(html,"utf-8");
htmlFile = File.createTempFile("coursepublish",".html");
//输出流
FileOutputStream outputStream = new FileOutputStream(htmlFile);
IOUtils.copy(inputStream, outputStream);
}catch (Exception ex){
log.error("页面静态化出现问题，课程id:{}",courseId,ex);
ex.printStackTrace();
}
return htmlFile;
}
@Autowired
MediaServiceClient mediaServiceClient;
@Override
public void uploadCourseHtml(Long courseId, File file) {
try {
//将file转成MultipartFile
MultipartFile multipartFile = MultipartSupportConfig.getMultipartFile(file);
//远程调用得到返回值
String upload = mediaServiceClient.upload(multipartFile, "course/" + courseId + ".html");
if(upload==null){
log.debug("远程调用走降级逻辑得到上传的结果为null,课程id:{}",courseId);
XueChengPlusException.cast("上传静态文件过程中存在异常");
}
}catch(Exception ex){
ex.printStackTrace();
XueChengPlusException.cast("上传静态文件过程中存在异常");
}
}
把下面这行代码复制粘贴到xuecheng-plus-content-api的ContentApplication的启动类上：
@EnableFeignClients(basePackages={"com.xuecheng.content.feignclient"})
xuecheng-plus-content-api的pom.xml文件中进行如下配置：
第1步：启动媒资，系统管理服务，网关启动。前端启动。内容服务以断点方式启动。
第2步：在前端提交审核，然后course_publish_pre会有一条记录，我们手动更改为审核通过（status设为202004），记得course_base表中相应记录的audit_status同样也要修改为审核通过。
第3步：任务调度中心的课程发布任务执行器启动。在（xuecheng-plus-content-service的service的jobhandler的CoursePublishTask下）execute下面打上断点。
第4步：点发布，记录会被写入course_publish表和mq_message表（是在content数据库下）。逐步跟进。
第5步：注意执行结束后，mq_message的消息要被删除，最终需要写入mq_message_history表。
4.16 课程搜索 P107
传统搜索方法：先找文章再找词。
全文检索方法：先找词再找文章。首先把词提取出来，创建索引，索引里面都是词，然后拿着词去搜索。
首先要创建索引，然后再搜索。
在虚拟机上已经有elasticsearch和kibana。尚未启动，输入下面4行命令启动：
docker stop elasticsearch
docker stop kibana
docker start elasticsearch
docker start kibana
Elasticsearch中的Index索引相当于MySQL的表
Elasticsearch中的Document文档相当于MySQL的行
Elasticsearch中的Field字段相当于MySQL的列
Elasticsearch中的Mapping字段相当于MySQL的列
解压下面的文件，然后拷贝到项目下面。
这里需要注意配置文件中的内容：
namespace和group要进行更改：
启动搜索工程。
在api-test下面创建xc-media-api，然后写入测试的代码：
课程信息索引同步：
实时性高：1.可以手动编写代码，在service里面同步。2.可以通过Canal实现。
实时性不强：1.MQ，向mysql写数据的时候向mq写入消息，搜索服务监听mq，收到消息后写入索引。存在问题：要保证消息可靠性，在向mq发消息要可靠，mq本身要可靠，服务监听mq也要可靠。代码实现比较复杂。
2.Logstash，开源实时日志分析平台ELK包括Elasticsearch、Kibana、Logstash，其中Logstash负责收集、解析和转换日志信息。可以实现MySQL与Elasticsearch之间数据同步。
3.任务调度，向mysql写数据的时候记录修改记录，开启一个定时任务根据修改记录将数据同步到Elasticsearch。
内容管理调搜索服务。
在xuecheng-plus-content的feignclient这个包下，定义一个SearchServiceClient接口，写如下代码：
@FeignClient(value="search",fallbackFactory = SearchServiceClientFallbackFactory.class)
public interface SearchServiceClient {
@PostMapping("/search/index/course")
public Boolean add(@RequestBody CourseIndex courseIndex);
}
把xuecheng-plus-search的po下的CourseIndex拷贝到xuecheng-plus-content-service的feignclient下。
在xuecheng-plus-content的feignclient这个包下，定义一个SearchServiceClientFallbackFactory接口，写如下代码：
@Slf4j
@Component
public class SearchServiceClientFallbackFactory implements FallbackFactory<SearchServiceClient> {
@Override
public SearchServiceClient create(Throwable throwable) {
return new SearchServiceClient() {
@Override
public Boolean add(CourseIndex courseIndex) {
log.error("添加课程索引发生熔断,索引信息:{},熔断异常:{}",courseIndex,throwable.toString(),throwable);
//走降级了返回false
return false;
}
};
}
}
在xuecheng-plus-content-service的service的jobhandler下的CoursePublishTask的代码如下：
@Slf4j
@Component
public class CoursePublishTask extends MessageProcessAbstract {
@Autowired
CoursePublishService coursePublishService;
@Autowired
SearchServiceClient searchServiceClient;
@Autowired
CoursePublishMapper coursePublishMapper;
//任务调度入口
@XxlJob("CoursePublishJobHandler")
public void coursePublishJobHandler() throws Exception{
//分片参数
int shardIndex = XxlJobHelper.getShardIndex();
int shardTotal = XxlJobHelper.getShardTotal();
//调用抽象类的方法执行任务
process(shardIndex,shardTotal,"course_publish",30,60);
}
//执行课程发布任务的逻辑,如果此方法抛出异常说明任务执行失败
@Override
public boolean execute(MqMessage mqMessage) {
//从mqMessage拿到课程id
Long courseId = Long.parseLong(mqMessage.getBusinessKey1());
//课程静态化上传到minio
generateCourseHtml(mqMessage,courseId);
//向elasticsearch写索引数据
saveCourseIndex(mqMessage,courseId);
//向redis写缓存
//课程静态化上传到minio
//返回true任务完成
return true;
}
//生成课程静态化页面并上传至文件系统
private void generateCourseHtml(MqMessage mqMessage,long courseId){
//消息id
Long taskId = mqMessage.getId();
MqMessageService mqMessageService = this.getMqMessageService();
//做任务幂等性处理
//取出该阶段执行状态
int stageOne = mqMessageService.getStageOne(taskId);
if(stageOne>0){
log.debug("课程静态化任务完成，无须处理...");
return;
}
//开始进行课程静态化,生成html页面
File file = coursePublishService.generateCourseHtml(courseId);
if(file==null){
XueChengPlusException.cast("生成的静态页面为空");
}
//将html上传到minio
coursePublishService.uploadCourseHtml(courseId,file);
//任务处理完成写任务状态为完成
mqMessageService.completedStageOne(taskId);
}
//保存课程索引信息 第二个阶段任务
private void saveCourseIndex(MqMessage mqMessage,long courseId){
//任务id
Long taskId = mqMessage.getId();
MqMessageService mqMessageService = this.getMqMessageService();
//取出第二个阶段状态
int stageTwo = mqMessageService.getStageTwo(taskId);
//任务幂等性处理
if(stageTwo>0){
log.debug("课程索引信息已写入，无需执行...");
return;
}
//查询课程信息，调用搜索服务添加索引接口
//从课程发布表查询课程信息
CoursePublish coursePublish = coursePublishMapper.selectById(courseId);
CourseIndex courseIndex = new CourseIndex();
BeanUtils.copyProperties(coursePublish,courseIndex);
//远程调用
Boolean add = searchServiceClient.add(courseIndex);
if(!add){
XueChengPlusException.cast("远程调用搜索服务添加课程索引失败");
}
//完成本阶段的任务
mqMessageService.completedStageTwo(courseId);
}
}
把GatewayApplication和ContentApplication和SearchApplication和SystemApplication和MediaApplication启动。
可以看到一些初始数据：
测试：
第1步：我拿最后一条数据做试验，先把图片上传上去。
第2步：然后点击提交审核。然后course_publish_pre会有一条记录，我们手动更改为审核通过（status设为202004），记得course_base表中相应记录的audit_status同样也要修改为审核通过。
第4步：点发布。可以看到新增了这门课。
五、认证授权模块
5.1 SpringSecurity认证授权测试 P108
什么是用户身份认证？用户去访问系统资源时要求验证用户的身份信息，身份合法即可继续访问。
常见的用户身份认证方式：用户名密码、微信扫码等。
项目包含：学生、学习机构老师、平台运营人员三类用户，每一类用户在访问项目受保护资源时都需要进行身份认证。
什么是用户授权？用户认证通过后去访问系统资源，系统会判断用户是否拥有访问资源的权限，只允许访问有权限的系统资源，没有权限的资源无法访问，这个过程叫用户授权。
微信扫码和QQ扫码能方便用户登录（省去了用户注册的成本），能够对资源进行共享。
认证功能几乎是每个项目都要具备的功能，并且它与业务无关，市面上有很多的认证框架。Spring Security。
把资料中的xuecheng-plus-search解压后拷贝到项目当中，更改bootstrap.yml配置文件中的如下内容：
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>
出现下面问题：
class lombok.javac.apt.LombokProcessor (in unnamed module @0x6002e944) cannot access class com.sun.tools.javac.processing.JavacProcessingEnvironment (in module jdk.compiler) because module jdk.compiler does not export com.sun.tools.javac.processing to unnamed module @0x6002e944
解决方法：把xuecheng-plus-parent的lombok版本调高。
访问localhost:63070/auth/user/52效果如下：
访问localhost:63070/auth/login
在登录界面输入用户名：zhangsan，密码：123，登录成功。反之提示登录失败。
加入如下注解：
@PreAuthorize("hasAuthority('p1')")
@PreAuthorize("hasAuthority('p2')")
重新启动项目，效果如下：
下面logout：
点击Log Out，然后输入用户名：lisi，密码：456。
授权：把权限赋予不同类别的用户，判断谁有权限，有权限就能访问资源。
过滤器是在请求到达之前的预处理或者后处理，拦截器是对方法调用的前后或者抛出异常时的处理，监听器是监听特定事件执行相应操作
5.2 OAuth2协议测试 P109
现在的问题是：一个新用户在网站没有信息，如果要注册需要填写一大堆的个人信息，如果可以通过扫码获取信息，会比较方便。
流程：客户端向用户申请到授权码，用户同意后客户端携带授权码去获取令牌，获取到令牌客户端携带令牌去获取用户信息。
把下面这个bean复制到WebSecurityConfig中
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
重新启动项目。 如果启动失败注意一定要用老师配套的jdk1.8，在第1天的资料中。
在api-test包下面创建一个xc-auth-api.http文件，
可以获取到授权码：
把授权码填在请求的url中
POST {{auth_host}}/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=authorization_code&code=w8QpqV&redirect_uri=http://www.51xuecheng.cn
密码模式：
POST {{auth_host}}/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username=zhangsan&password=123
5.3 jwt令牌 P110
现在的问题是：认证服务发的令牌，资源服务要每次请求认证服务才能拿到令牌。
现在想解决上面的问题，可以使用JWT格式的令牌解决上面的问题。
jwt令牌包含3个方面：Header、Payload、Signature
Header里面包含算法类型。Payload里面是内容，不建议存放敏感信息，因为可以被解码还原为原始内容。前2部分用的编码方式都是base64url。
Signature是签名，用于防止jwt内容被篡改。只要秘钥不泄露，就无法篡改后不被知觉。
现在资源服务只需要获得秘钥，就能验证JWT。
如果认证服务和资源服务使用相同秘钥，叫作对称加密，效率高，秘钥泄露可以伪造jwt令牌。
测试的时候只需要把TokenConfig的配置全部换成下面的配置：
重新启动项目，点击密码模式登录，头、载体、签名之间用.号分割。
5.4 资源服务继承JWT P111
逻辑：客户端访问门户，通过统一认证入口，请求统一认证服务，如果认证成功，将jwt令牌颁发给客户端，客户端携带jwt令牌才能去访问教学管理、选课学习、运营管理这些模块。
首先让微服务整合spring security管控所有的资源。
把spring security的依赖加入到xuecheng-plus-content-api。
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>
将TokenConfig和ResourceServiceConfig拷贝到content下的config下，config要新建。
ResourceServiceConfig的RESOURCE_ID不要乱变要和前面的一致。
要管控的文件全部在这里配（注意老师给的初始文件，配置这里是注释掉的）：
启动content服务。
访问下面的会提示说请求不到：
正常时能访问到。加入jwt后访问不到：
先用Auth的方法获取到令牌，加上令牌后访问就能获取到资源。
5.5 网关认证 P112
网关的职责：一个是路由转发，一个是进行校验。
针对认证：1.网站白名单维护，针对不用认证的URL全部放行。2.校验jwt的合法性。校验jwt的合法性，jwt合法则放行，不合法则阻塞。
在网关工程添加如下依赖：
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
把资料中的文件全部拷贝到网关服务中，格式如下：
在security-whitelist.properties中配置的是白名单：
如下是白名单的位置：
记得先把临时全部放行那条注释掉：
启动gateway、auth、content服务。
在xuecheng-plus-content-api中把config下的ResourceServerConfig给屏蔽掉：
注意事项：1.要在网关添加依赖。2.读懂网关的过滤器。3.要配置白名单。4.在微服务要放行所有。
可以在网关的如下位置打断点进行跟踪调试：
访问如下的请求：
可以看到请求请求到的token
5.6 连接用户数据库 P113
首先要把xuecheng-plus-auth的config下的WebSecurityConfig这个类的配置用户信息服务部分给注释起来。
在xuecheng-plus-auth的ucenter下面创建service/impl包，然后创建一个UserServiceImpl类，写入如下代码：
@Slf4j
@Component
public class UserServiceImpl implements UserDetailsService {
@Autowired
XcUserMapper xcUserMapper;
@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
//账号
String username = s;
//根据username账号查询数据库
XcUser xcUser = xcUserMapper.selectOne(new LambdaQueryWrapper<XcUser>().eq(XcUser::getUsername, s));
//查询到用户不存在，返回null即可
if(xcUser==null){
return null;
}
//如果查到了用户拿到正确的密码，最终封装成一个UserDetails对象给spring security框架返回，由
String password = xcUser.getPassword();
//权限
String[] authorities = {"test"};
UserDetails userDetails = User.withUsername(username).password(password).authorities(authorities).build();
return userDetails;
}
}
在WebSecurityConfig中写入如下代码：
public static void main(String[] args) {
String password="111111";
PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//生成密码
for(int i=0;i<5;i++){
String encode = passwordEncoder.encode(password);
System.out.println(encode);
}
}
执行后，可以看到生成的每个串都不一样：
可以看到代码的每次比对都是一致的：
测试代码如下：
public static void main(String[] args) {
String password="111111";
PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//生成密码
for(int i=0;i<5;i++){
String encode = passwordEncoder.encode(password);
System.out.println(encode);
boolean matches = passwordEncoder.matches(password, encode);
System.out.println(matches);
}
}
修改下面这个地方：
数据库如下：
测试：在如下位置打断点
当用户名为zhangsan时因为数据库里没有匹配的所以失败
接下来把username改为t1，然后密码改为111111，可以正常获取到token。
5.7 扩展用户信息 P114
用户的相关信息需要记录到令牌，像昵称，头像，用户id都要记录进去，所以需要扩展用户的信息。
现在采用的方案是不仅存放username，同时还存放一大堆的东西进去。
在api-test包下的xc-auth-api.http下写入如下代码，token后面填写密码模式获取到的token
###校验jwt令牌
POST {{auth_host}}/auth/oauth/check_token?token=
可以看到json解析出来的内容就很多了！
5.8 工具类获取用户身份 P115
在xuecheng-plus-content-api的content下面建一个util，在util下面创建一个SecurityUtil类，把代码全部拷贝进去：
在CourseBaseInfoController中，现在可以直接通过SecurityUtil.getUser()来获取用户的信息。
重新启动content服务，以断点调试的方式启动。然后在xc-content-api.http中执行下面的方法：
可以看到获取到了user的信息。
5.9 统一认证入口 P116
统一认账入口，包括：账号密码认证，微信扫码认证，手机验证码认证。
首先要统一请求的参数，建了一个统一的认证类统一认证请求的参数统一为AuthParamsDto。
第1步：是对xuecheng-plus-auth的ucenter的service的impl下的UserServiceImpl类的代码进行修改，主要是将传入的json转成AuthParamsDto对象，在loadUserByUsername的开头写入如下代码：
//将传入的json转成AuthParamsDto对象
AuthParamsDto authParamsDto = null;
try {
authParamsDto = JSON.parseObject(s, AuthParamsDto.class);
} catch (Exception e) {
throw new RuntimeException("请求认证的参数不符合要求");
}
//账号
String username = authParamsDto.getUsername();
第2步：在api-test下的xc-auth-api.http中，添加如下的代码：
### 密码模式,请求AuthParamsDto参数
POST {{auth_host}}/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username={"username":"t1","password":"111111","authType":"password"}
第3步：在xuecheng-plus-auth的config下创建DaoAuthenticationProviderCustom下面，加入下面的代码：
//重写了DaoAuthenticationProvider的校验密码的方法，因为我们统一了认证入口，有一些认证方式不需要校验密码
@Component
public class DaoAuthenticationProviderCustom extends DaoAuthenticationProvider {
@Autowired
public void setUserDetailsService(UserDetailsService userDetailsService){
super.setUserDetailsService(userDetailsService);
}
@Override
protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
//子类重写父类方法，为空就好
}
}
不是所有的验证都要校验密码，手机验证码就不需要校验密码。
第4步：进入到config下的WebSecurityConfig中，写入如下代码：
@Autowired
DaoAuthenticationProviderCustom daoAuthenticationProviderCustom;
@Override
protected void configure(AuthenticationManagerBuilder auth)throws Exception{
auth.authenticationProvider(daoAuthenticationProviderCustom);
}
测试：在下面的位置打上断点
第5步：在xuecheng-plus-auth的service下创建AuthService
//统一的认证接口
public interface AuthService {
//认证方法
XcUserExt execute(AuthParamsDto authParamsDto);
}
第6步：策略模式，根据不同的认证方式进来有不同的策略。
//账号名密码方式
@Service("password_authservice")
public class PasswordAuthServiceImpl implements AuthService {
@Override
public XcUserExt execute(AuthParamsDto authParamsDto) {
return null;
}
}
//微信扫码认证
@Service("wx_authservice")
public class WxAuthServiceImpl implements AuthService {
@Override
public XcUserExt execute(AuthParamsDto authParamsDto) {
return null;
}
}
第7步：可以在UserServiceImpl中根据认证类型从spring容器中取出指定的bean。在如下位置添加如下代码：
//认证类型，有password，wx...
String authType = authParamsDto.getAuthType();
//根据认证类型从spring容器中取出指定的bean
String beanName = authType+"_authservice";
AuthService authService = applicationContext.getBean(beanName,AuthService.class);
//调用
XcUserExt execute = authService.execute(authParamsDto);
@Autowired
ApplicationContext applicationContext;
5.10 统一账号密码认证 P117
在xuecheng-plus-auth的service的impl下的PasswordAuthServiceImpl中，写入如下代码：
//账号名密码方式
@Service("password_authservice")
public class PasswordAuthServiceImpl implements AuthService {
@Autowired
XcUserMapper xcUserMapper;
@Autowired
PasswordEncoder passwordEncoder;
@Override
public XcUserExt execute(AuthParamsDto authParamsDto) {
//账号
String username = authParamsDto.getUsername();
//todo:校验验证码
//账号是否存在,根据username账号查询数据库
XcUser xcUser = xcUserMapper.selectOne(new LambdaQueryWrapper<XcUser>().eq(XcUser::getUsername,username));
//查询到用户不存在,要返回null即可,spring security框架抛出异常用户不存在
if(xcUser==null){
throw new RuntimeException("账号不存在");
}
//校验密码是否正确
//如果查到了用户拿到正确的密码
String passwordDb = xcUser.getPassword();
//拿到用户输入的密码
String passwordForm = authParamsDto.getPassword();
//校验密码
boolean matches = passwordEncoder.matches(passwordForm, passwordDb);
if(!matches){
throw new RuntimeException("账号或密码错误");
}
XcUserExt xcUserExt = new XcUserExt();
BeanUtils.copyProperties(xcUser,xcUserExt);
return xcUserExt;
}
}
在xuecheng-plus-auth的service的impl下的UserServiceImpl中写入如下代码：
@Slf4j
@Component
public class UserServiceImpl implements UserDetailsService {
@Autowired
XcUserMapper xcUserMapper;
@Autowired
ApplicationContext applicationContext;
@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
//将传入的json转成AuthParamsDto对象
AuthParamsDto authParamsDto = null;
try {
authParamsDto = JSON.parseObject(s, AuthParamsDto.class);
} catch (Exception e) {
throw new RuntimeException("请求认证的参数不符合要求");
}
//认证类型，有password，wx...
String authType = authParamsDto.getAuthType();
//根据认证类型从spring容器中取出指定的bean
String beanName = authType+"_authservice";
AuthService authService = applicationContext.getBean(beanName,AuthService.class);
//调用统一execute方法完成认证
XcUserExt xcUserExt = authService.execute(authParamsDto);
//封装xcUserExt用户信息为UserDetails
UserDetails userPrincipal = getUserPrincipal(xcUserExt);
return userPrincipal;
}
//查询用户信息
public UserDetails getUserPrincipal(XcUserExt xcUser){
String password = xcUser.getPassword();
//权限
String[] authorities = {"test"};
xcUser.setPassword(null);
String userJson = JSON.toJSONString(xcUser);
UserDetails userDetails = User.withUsername(userJson).password(password).authorities(authorities).build();
return userDetails;
}
}
测试：在xc-auth-api.http发送如下请求：
在下面位置打上断点，逐步跟踪，看看最终结果是否正确。
5.11 部署验证码服务 P118
验证码可以防止恶性攻击。具有认证、找回密码、支付验证、人机判断等功能。
解压下面的zip包，然后拷贝到项目当中：
修改yaml配置文件中的配置：
在nacos中配置redis：
在api-test下创建xc-checkcode-api.http，写入如下代码：
### 申请验证码
POST {{checkcode_host}}/checkcode/pic
生成的效果如下：
key会被存储在redis中：
复制图片链接，打开即可看到校验码：
发送下面的代码来看是否正确：
### 校验验证码
POST {{checkcode_host}}/checkcode/verify?key=checkcode:2d6c2fa5124641fc83339a6e16718cbc&code=bwst
5.12 账号密码认证测试 P119
启动网关和验证码服务，redis也要启动，记得前端的nginx和项目的serve也要启动！
然后打开前端的登录页面，是401状态。可以到网关服务的security-whitelist.properties中临时把所有页面放行：
可以看到验证码出现：
然后可以将xuecheng-plus-auth服务也断点启动，在如下位置打上断点：
如果出现下面的问题：
输入用户名、密码、验证码后点击确定，跳转到下面：
在xuecheng-plus-auth的ucenter下面创建feignclient包。在feignclient包下创建CheckCodeClient接口，写入如下代码：
@FeignClient(value = "checkcode",fallbackFactory = CheckCodeClientFactory.class)
@RequestMapping("/checkcode")
public interface CheckCodeClient {
@PostMapping(value="/verify")
public Boolean verify(@RequestParam("key") String key, @RequestParam("code") String code);
}
同样在feignclient包系创建CheckCodeClientFactory类，写入如下代码：
@Slf4j
@Component
public class CheckCodeClientFactory implements FallbackFactory<CheckCodeClient> {
@Override
public CheckCodeClient create(Throwable throwable) {
return new CheckCodeClient() {
@Override
public Boolean verify(String key, String code) {
log.debug("调用验证码服务熔断异常:{}",throwable.getMessage());
return null;
}
};
}
}
在bootstrap.yml中写入如下配置：
完善之后的PasswordAuthServiceImpl代码如下：
//账号名密码方式
@Service("password_authservice")
public class PasswordAuthServiceImpl implements AuthService {
@Autowired
XcUserMapper xcUserMapper;
@Autowired
PasswordEncoder passwordEncoder;
@Autowired
CheckCodeClient checkCodeClient;
@Override
public XcUserExt execute(AuthParamsDto authParamsDto) {
//账号
String username = authParamsDto.getUsername();
//输入的验证码
String checkcode = authParamsDto.getCheckcode();
//验证码对应的key
String checkcodekey = authParamsDto.getCheckcodekey();
if(StringUtils.isEmpty(checkcode)||StringUtils.isEmpty(checkcode)){
throw new RuntimeException("请输入验证码");
}
//远程调用验证码服务接口去校验验证码
Boolean verify = checkCodeClient.verify(checkcodekey, checkcode);
if(verify == null || !verify){
throw new RuntimeException("验证码输入错误");
}
//账号是否存在,根据username账号查询数据库
XcUser xcUser = xcUserMapper.selectOne(new LambdaQueryWrapper<XcUser>().eq(XcUser::getUsername,username));
//查询到用户不存在,要返回null即可,spring security框架抛出异常用户不存在
if(xcUser==null){
throw new RuntimeException("账号不存在");
}
//校验密码是否正确
//如果查到了用户拿到正确的密码
String passwordDb = xcUser.getPassword();
//拿到用户输入的密码
String passwordForm = authParamsDto.getPassword();
//校验密码
boolean matches = passwordEncoder.matches(passwordForm, passwordDb);
if(!matches){
throw new RuntimeException("账号或密码错误");
}
XcUserExt xcUserExt = new XcUserExt();
BeanUtils.copyProperties(xcUser,xcUserExt);
return xcUserExt;
}
}
在下面打上断点：
