├── src
    ├── main
    │   ├── resources
    │   │   ├── static
    │   │   │   ├── mine
    │   │   │   │   └── 这里放的是用户主页.txt
    │   │   │   └── video
    │   │   │   │   └── 这里放的是视频页面.txt
    │   │   ├── mybatis
    │   │   │   ├── mybatis-config.xml
    │   │   │   └── mappers
    │   │   │   │   ├── web
    │   │   │   │       ├── WordsMapper.xml
    │   │   │   │       └── InfoMapper.xml
    │   │   │   │   └── video
    │   │   │   │       ├── CommentMapper.xml
    │   │   │   │       ├── CollectionMapper.xml
    │   │   │   │       ├── AccountMapper.xml
    │   │   │   │       └── VideoMapper.xml
    │   │   ├── application.yml
    │   │   └── logback.xml
    │   └── java
    │   │   └── com
    │   │       └── lingyi
    │   │           └── RootGet
    │   │               ├── mapper
    │   │                   ├── web
    │   │                   │   ├── InfoMapper.java
    │   │                   │   └── WordsMapper.java
    │   │                   └── video
    │   │                   │   ├── CommentMapper.java
    │   │                   │   ├── AccountMapper.java
    │   │                   │   ├── CollectionMapper.java
    │   │                   │   └── VideoMapper.java
    │   │               ├── RootGetApplication.java
    │   │               ├── config
    │   │                   ├── ObjectMapperConfig.java
    │   │                   ├── InterceptorConfig.java
    │   │                   └── ScheduleConfig.java
    │   │               ├── entry
    │   │                   ├── Danmaku.java
    │   │                   ├── Collection.java
    │   │                   ├── Words.java
    │   │                   ├── Info.java
    │   │                   ├── Account.java
    │   │                   ├── Comment.java
    │   │                   └── Video.java
    │   │               ├── tools
    │   │                   ├── MD5Transfer.java
    │   │                   ├── SnowFlake.java
    │   │                   ├── Constant.java
    │   │                   └── RedisTools.java
    │   │               ├── controller
    │   │                   ├── GlobalExceptionHandler.java
    │   │                   ├── ImageController.java
    │   │                   ├── Viewer.java
    │   │                   ├── CollectionController.java
    │   │                   ├── CommentController.java
    │   │                   ├── Administrator.java
    │   │                   ├── AccountController.java
    │   │                   └── VideoController.java
    │   │               ├── filter
    │   │                   ├── AddHeader.java
    │   │                   └── Interceptor.java
    │   │               └── datasource
    │   │                   ├── web
    │   │                       └── DataSourceConfigWeb.java
    │   │                   └── video
    │   │                       └── DataSourceConfigVideo.java
    └── test
    │   └── java
    │       └── com
    │           └── lingyi
    │               └── RootGet
    │                   └── RootGetApplicationTests.java
├── .mvn
    └── wrapper
    │   ├── maven-wrapper.jar
    │   └── maven-wrapper.properties
├── .gitignore
├── LICENSE
├── pom.xml
├── mvnw.cmd
└── mvnw


/src/main/resources/static/mine/这里放的是用户主页.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/main/resources/static/video/这里放的是视频页面.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.mvn/wrapper/maven-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KotokawaAkira/VideoStationServer/HEAD/.mvn/wrapper/maven-wrapper.jar


--------------------------------------------------------------------------------
/.mvn/wrapper/maven-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.5/apache-maven-3.8.5-bin.zip
2 | wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar
3 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/mapper/web/InfoMapper.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.mapper.web;
 2 | 
 3 | import com.lingyi.RootGet.entry.Info;
 4 | import org.apache.ibatis.annotations.Mapper;
 5 | 
 6 | import java.util.List;
 7 | 
 8 | @Mapper
 9 | public interface InfoMapper {
10 |     List<Info> getInfo();
11 | }
12 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/mapper/web/WordsMapper.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.mapper.web;
 2 | 
 3 | import com.lingyi.RootGet.entry.Words;
 4 | import org.apache.ibatis.annotations.Mapper;
 5 | 
 6 | import java.util.List;
 7 | 
 8 | @Mapper
 9 | public interface WordsMapper {
10 |     List<Words> getWords();
11 | }
12 | 


--------------------------------------------------------------------------------
/src/main/resources/mybatis/mybatis-config.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8" ?>
2 | <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
3 |         "http://mybatis.org/dtd/mybatis-3-config.dtd">
4 | <configuration>
5 | <!--    <settings>-->
6 | <!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
7 | <!--    </settings>-->
8 | </configuration>


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/RootGetApplication.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet;
 2 | 
 3 | import org.springframework.boot.SpringApplication;
 4 | import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 | 
 6 | @SpringBootApplication
 7 | public class RootGetApplication {
 8 | 
 9 | 	public static void main(String[] args) {
10 | 		SpringApplication.run(RootGetApplication.class, args);
11 | 	}
12 | 
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/resources/mybatis/mappers/web/WordsMapper.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <!DOCTYPE mapper
3 |         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4 |         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5 | <mapper namespace="com.lingyi.RootGet.mapper.web.WordsMapper">
6 |     <select id="getWords" resultType="com.lingyi.RootGet.entry.Words">
7 |         SELECT * FROM words;
8 |     </select>
9 | </mapper>


--------------------------------------------------------------------------------
/src/main/resources/mybatis/mappers/web/InfoMapper.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <!DOCTYPE mapper
3 |         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4 |         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5 | <mapper namespace="com.lingyi.RootGet.mapper.web.InfoMapper">
6 |     <select id="getInfo" resultType="com.lingyi.RootGet.entry.Info">
7 |         SELECT * FROM info ORDER BY date DESC;
8 |     </select>
9 | </mapper>


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/config/ObjectMapperConfig.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.config;
 2 | 
 3 | import com.fasterxml.jackson.databind.ObjectMapper;
 4 | import org.springframework.context.annotation.Bean;
 5 | import org.springframework.context.annotation.Configuration;
 6 | 
 7 | @Configuration
 8 | public class ObjectMapperConfig {
 9 |     @Bean
10 |     public ObjectMapper objectMapper(){
11 |         return new ObjectMapper();
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | HELP.md
 2 | target/
 3 | !.mvn/wrapper/maven-wrapper.jar
 4 | !**/src/main/**/target/
 5 | !**/src/test/**/target/
 6 | 
 7 | ### STS ###
 8 | .apt_generated
 9 | .classpath
10 | .factorypath
11 | .project
12 | .settings
13 | .springBeans
14 | .sts4-cache
15 | 
16 | ### IntelliJ IDEA ###
17 | .idea
18 | *.iws
19 | *.iml
20 | *.ipr
21 | 
22 | ### NetBeans ###
23 | /nbproject/private/
24 | /nbbuild/
25 | /dist/
26 | /nbdist/
27 | /.nb-gradle/
28 | build/
29 | !**/src/main/**/build/
30 | !**/src/test/**/build/
31 | 
32 | ### VS Code ###
33 | .vscode/
34 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/entry/Danmaku.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.entry;
 2 | 
 3 | import java.util.List;
 4 | 
 5 | public class Danmaku {
 6 |     private int code;
 7 |     private List<List<String>> data;
 8 | 
 9 |     public int getCode() {
10 |         return code;
11 |     }
12 | 
13 |     public void setCode(int code) {
14 |         this.code = code;
15 |     }
16 | 
17 |     public List<List<String>> getData() {
18 |         return data;
19 |     }
20 | 
21 |     public void setData(List<List<String>> data) {
22 |         this.data = data;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/main/resources/application.yml:
--------------------------------------------------------------------------------
 1 | server:
 2 |   servlet:
 3 |     context-path: 
 4 |   port: 
 5 | 
 6 | spring:
 7 |   servlet:
 8 |     multipart:
 9 |       max-file-size: 500MB
10 |       max-request-size: -1
11 |   datasource:
12 |     web:
13 |       url: 
14 |       username: 
15 |       password: 
16 |       driver-class-name: 
17 |     video:
18 |       url: 
19 |       username: 
20 |       password: 
21 |       driver-class-name: 
22 | 
23 |   redis:
24 |     host: 
25 |     port: 
26 |     password: 
27 | 
28 | mybatis:
29 |   config-location: classpath:mybatis/mybatis-config.xml
30 | 
31 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/mapper/video/CommentMapper.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.mapper.video;
 2 | 
 3 | import com.lingyi.RootGet.entry.Comment;
 4 | import org.apache.ibatis.annotations.Mapper;
 5 | import org.springframework.transaction.annotation.Transactional;
 6 | 
 7 | import java.util.List;
 8 | 
 9 | @Mapper
10 | public interface CommentMapper {
11 |     Comment getCommentsById(long id);
12 |     List<Comment> getCommentsByForId(long forId);
13 |     int addComment(Comment comment);
14 |     int deleteComment(Comment comment);
15 |     void updateName(String oldName,String newName);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/mapper/video/AccountMapper.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.mapper.video;
 2 | 
 3 | import com.lingyi.RootGet.entry.Account;
 4 | import org.apache.ibatis.annotations.Mapper;
 5 | import org.springframework.transaction.annotation.Transactional;
 6 | import reactor.util.annotation.NonNull;
 7 | 
 8 | import java.util.List;
 9 | 
10 | 
11 | @Mapper
12 | public interface AccountMapper {
13 |     Account selectOneById(@NonNull  long id);
14 |     List<Account> selectByKeywords(String keywords);
15 |     void addOne(@NonNull Account account);
16 |     void updateOne(@NonNull Account account);
17 | }
18 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/mapper/video/CollectionMapper.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.mapper.video;
 2 | 
 3 | import org.apache.ibatis.annotations.MapKey;
 4 | import org.apache.ibatis.annotations.Mapper;
 5 | import org.apache.ibatis.annotations.Param;
 6 | 
 7 | import java.util.List;
 8 | import java.util.Map;
 9 | 
10 | @Mapper
11 | public interface CollectionMapper {
12 |     @MapKey("name")
13 |     Map<String,Object> selectAll();
14 |     boolean isExists(String name);
15 |     void addCollections(@Param("list") Map<String,String> map);
16 |     void updateCollections(@Param("list") Map<String,String> map);
17 |     void delete(List<String> collectionKeys);
18 | }
19 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/entry/Collection.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.entry;
 2 | 
 3 | import java.util.Set;
 4 | 
 5 | public class Collection {
 6 |     private String name;
 7 |     private Set<Video> videos;
 8 | 
 9 |     public String getName() {
10 |         return name;
11 |     }
12 | 
13 |     public Collection setName(String name) {
14 |         this.name = name;
15 |         return this;
16 |     }
17 | 
18 |     public Set<Video> getVideos() {
19 |         return videos;
20 |     }
21 | 
22 |     public void setVideos(Set<Video> videos) {
23 |         this.videos = videos;
24 |     }
25 | 
26 |     @Override
27 |     public String toString() {
28 |         return "Collection{" +
29 |                 "name='" + name + '\'' +
30 |                 ", videos=" + videos +
31 |                 '}';
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/tools/MD5Transfer.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.tools;
 2 | 
 3 | import java.math.BigInteger;
 4 | import java.security.MessageDigest;
 5 | import java.security.NoSuchAlgorithmException;
 6 | 
 7 | public class MD5Transfer {
 8 |     public static String encode(String str){
 9 |         String string = null;
10 |         try{
11 |         MessageDigest md = MessageDigest.getInstance("MD5");
12 |         // 计算md5函数
13 |         md.update(str.getBytes());
14 |         // digest()最后确定返回md5 hash值，返回值为8为字符串。因为md5 hash值是16位的hex值，实际上就是8位的字符
15 |         // BigInteger函数则将8位的字符串转换成16位hex值，用字符串来表示；得到字符串形式的hash值
16 |         string = new BigInteger(1, md.digest()).toString(16);
17 |         }catch(NoSuchAlgorithmException e){
18 |             e.printStackTrace();
19 |         }
20 |         return string;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/mapper/video/VideoMapper.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.mapper.video;
 2 | 
 3 | import com.lingyi.RootGet.entry.Video;
 4 | import org.apache.ibatis.annotations.Mapper;
 5 | import org.apache.ibatis.annotations.Param;
 6 | import org.springframework.transaction.annotation.Transactional;
 7 | import reactor.util.annotation.NonNull;
 8 | 
 9 | import java.util.List;
10 | 
11 | @Mapper
12 | public interface VideoMapper {
13 |     List<Video> selectAll();
14 |     boolean isExists(String id);
15 |     Video selectOneById(@NonNull String id);
16 |     List<Video> selectByKeywords(String keywords);
17 |     List<Video> selectByUp(long up);
18 |     void addOne(@NonNull Video video);
19 |     void updateOne(@NonNull Video video);
20 |     void updateVideos(@NonNull @Param("list") List<Video> list);
21 |     void addVideos(@NonNull @Param("list") List<Video> list);
22 |     void deleteOne(String id);
23 |     void updateUpName(String oldName,String newName);
24 | }
25 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/GlobalExceptionHandler.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.controller;
 2 | 
 3 | import org.slf4j.Logger;
 4 | import org.slf4j.LoggerFactory;
 5 | import org.springframework.web.bind.annotation.ExceptionHandler;
 6 | import org.springframework.web.bind.annotation.RestControllerAdvice;
 7 | 
 8 | import javax.servlet.http.HttpServletResponse;
 9 | 
10 | @RestControllerAdvice
11 | public class GlobalExceptionHandler {
12 |     private final Logger log = LoggerFactory.getLogger("videoLog");
13 |     @ExceptionHandler
14 |     public void handler(Exception e, HttpServletResponse response){
15 |         response.setStatus(500);
16 |         StackTraceElement[] stackTrace = e.getStackTrace();
17 |         log.error("==============================");
18 |         log.error("msg:"+e.getMessage());
19 |         for(int i=0;i<5;i++){
20 |             log.error("class:"+stackTrace[i].getClassName()+" method:"+stackTrace[i].getMethodName()+" lines:"+stackTrace[i].getLineNumber());
21 |         }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 KotokawaAkira
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/config/InterceptorConfig.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.config;
 2 | 
 3 | import com.lingyi.RootGet.filter.Interceptor;
 4 | import org.springframework.beans.factory.annotation.Autowired;
 5 | import org.springframework.stereotype.Component;
 6 | import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
 7 | import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 8 | import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 9 | 
10 | //@Component
11 | public class InterceptorConfig implements WebMvcConfigurer {
12 |     private final Interceptor interceptor;
13 |     @Autowired
14 |     public InterceptorConfig(Interceptor interceptor){
15 |         this.interceptor = interceptor;
16 |     }
17 |     @Override
18 |     public void addInterceptors(InterceptorRegistry registry) {
19 |         InterceptorRegistration registration = registry.addInterceptor(interceptor);
20 |         //registration.addPathPatterns("/api/*");
21 |         registration.excludePathPatterns("/Mine/*","/Video/*","/video/*","/getWords","/getWebs","/api/account/*","/api/video/*","/api/comments/getComments/*","/api/collection/getCollectionByUid/*");
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/filter/AddHeader.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.filter;
 2 | 
 3 | import org.springframework.stereotype.Component;
 4 | import org.springframework.util.StringUtils;
 5 | import org.springframework.web.filter.OncePerRequestFilter;
 6 | 
 7 | import javax.servlet.FilterChain;
 8 | import javax.servlet.ServletException;
 9 | import javax.servlet.http.HttpServletRequest;
10 | import javax.servlet.http.HttpServletResponse;
11 | import java.io.IOException;
12 | 
13 | @Component
14 | public class AddHeader extends OncePerRequestFilter {
15 |     @Override
16 |     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
17 |         String origin = request.getHeader("Origin");
18 |         String method = request.getMethod();
19 | 
20 |         response.addHeader("Access-Control-Allow-Origin",origin);
21 |         response.addHeader("Access-Control-Allow-Headers","Content-Type,Sec-Fetch-Site");
22 |         response.addHeader("Access-Control-Allow-Credentials","true");
23 | 
24 |         if(method.equals("OPTIONS")){
25 |             response.setStatus(200);
26 |             return;
27 |         }
28 |         filterChain.doFilter(request,response);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/entry/Words.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.entry;
 2 | 
 3 | public class Words {
 4 |     private String word,translate,character,masterpiece;
 5 | 
 6 |     public String getWord() {
 7 |         return word;
 8 |     }
 9 | 
10 |     public void setWord(String word) {
11 |         this.word = word;
12 |     }
13 | 
14 |     public String getTranslate() {
15 |         return translate;
16 |     }
17 | 
18 |     public void setTranslate(String translate) {
19 |         this.translate = translate;
20 |     }
21 | 
22 |     public String getCharacter() {
23 |         return character;
24 |     }
25 | 
26 |     public void setCharacter(String character) {
27 |         this.character = character;
28 |     }
29 | 
30 |     public String getMasterpiece() {
31 |         return masterpiece;
32 |     }
33 | 
34 |     public void setMasterpiece(String masterpiece) {
35 |         this.masterpiece = masterpiece;
36 |     }
37 | 
38 |     @Override
39 |     public String toString() {
40 |         return "Words{" +
41 |                 "word='" + word + '\'' +
42 |                 ", translate='" + translate + '\'' +
43 |                 ", character='" + character + '\'' +
44 |                 ", masterpiece='" + masterpiece + '\'' +
45 |                 '}';
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/main/resources/mybatis/mappers/video/CommentMapper.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE mapper
 3 |         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4 |         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 | <mapper namespace="com.lingyi.RootGet.mapper.video.CommentMapper">
 6 |     <select id="getCommentsById" parameterType="string" resultType="com.lingyi.RootGet.entry.Comment">
 7 |         SELECT id,text,time,time_long,userName,uid,`like`,forId FROM comment WHERE id = #{id};
 8 |     </select>
 9 |     <select id="getCommentsByForId" parameterType="object" resultType="com.lingyi.RootGet.entry.Comment">
10 |         SELECT id,text,time,time_long,userName,uid,`like`,forId FROM comment WHERE forId = #{forId} ORDER BY `like` DESC,time DESC ;
11 |     </select>
12 |     <insert id="addComment" parameterType="com.lingyi.RootGet.entry.Comment">
13 |         INSERT INTO comment (text,userName,uid,forId) VALUES (#{text},#{userName},#{uid},#{forId});
14 |     </insert>
15 |     <delete id="deleteComment" parameterType="com.lingyi.RootGet.entry.Comment">
16 |         DELETE FROM comment WHERE id = #{id};
17 |     </delete>
18 |     <update id="updateName" parameterType="string">
19 |         UPDATE comment SET userName = #{newName} WHERE userName = #{oldName};
20 |     </update>
21 | </mapper>


--------------------------------------------------------------------------------
/src/main/resources/mybatis/mappers/video/CollectionMapper.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE mapper
 3 |         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4 |         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 | <mapper namespace="com.lingyi.RootGet.mapper.video.CollectionMapper">
 6 |     <select id="selectAll" resultType="map">
 7 |         SELECT `name`, list
 8 |         FROM collection;
 9 |     </select>
10 |     <!--    表中是否存在数据-->
11 |     <select id="isExists" parameterType="string" resultType="boolean">
12 |         SELECT IFNULL((SELECT TRUE FROM collection WHERE name = #{name} LIMIT 1),FALSE);
13 |     </select>
14 |     <!--    添加多个-->
15 |     <insert id="addCollections" parameterType="map">
16 |         <foreach collection="list" item="item" index="key" separator=";">
17 |             INSERT INTO collection(name,list)
18 |             VALUES (#{key},#{item})
19 |         </foreach>
20 |     </insert>
21 |     <!--    更新多个-->
22 |     <update id="updateCollections" parameterType="map">
23 |         <foreach collection="list" item="item" index="key" separator=";">
24 |             UPDATE collection
25 |             SET list = #{item}
26 |             WHERE `name` = #{key}
27 |         </foreach>
28 |     </update>
29 |     <delete id="delete" parameterType="list">
30 |         DELETE FROM collection WHERE name =
31 |         <foreach collection="list" item="item" separator="AND ">
32 |             #{item}
33 |         </foreach>
34 |     </delete>
35 | </mapper>


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/ImageController.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.controller;
 2 | 
 3 | import com.lingyi.RootGet.tools.Constant;
 4 | import org.springframework.web.bind.annotation.GetMapping;
 5 | import org.springframework.web.bind.annotation.RequestParam;
 6 | import org.springframework.web.bind.annotation.RestController;
 7 | 
 8 | import javax.servlet.ServletOutputStream;
 9 | import javax.servlet.http.HttpServletResponse;
10 | import java.io.*;
11 | 
12 | @RestController
13 | public class ImageController {
14 |     @GetMapping("/image")
15 |     public void getImage(@RequestParam("filePath") String filePath, HttpServletResponse response) {
16 |         File file = new File( filePath);
17 |         response.setHeader("Content-Type", "image/" + Constant.getFileType(file));
18 |         response.setContentLengthLong(file.length());
19 |         ServletOutputStream outputStream;
20 |         try {
21 |             outputStream = response.getOutputStream();
22 |             writeStream(file, outputStream);
23 |         } catch (IOException e) {
24 |             throw new RuntimeException(e);
25 |         }
26 |     }
27 |     public void writeStream(File file, OutputStream outputStream) throws IOException {
28 |         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
29 |         int len;
30 |         byte[] bytes = new byte[2048];
31 |         while((len=bis.read(bytes))!=-1){
32 |             outputStream.write(bytes,0,len);
33 |         }
34 |         bis.close();
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/test/java/com/lingyi/RootGet/RootGetApplicationTests.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet;
 2 | 
 3 | import com.fasterxml.jackson.core.JsonProcessingException;
 4 | import com.lingyi.RootGet.config.ScheduleConfig;
 5 | import com.lingyi.RootGet.entry.Collection;
 6 | import com.lingyi.RootGet.entry.Comment;
 7 | import com.lingyi.RootGet.entry.Video;
 8 | import com.lingyi.RootGet.mapper.video.CollectionMapper;
 9 | import com.lingyi.RootGet.mapper.video.CommentMapper;
10 | import com.lingyi.RootGet.mapper.video.AccountMapper;
11 | import com.lingyi.RootGet.mapper.video.VideoMapper;
12 | import com.lingyi.RootGet.tools.RedisTools;
13 | import org.junit.jupiter.api.Test;
14 | import org.springframework.beans.factory.annotation.Autowired;
15 | import org.springframework.boot.test.context.SpringBootTest;
16 | import org.springframework.data.redis.core.StringRedisTemplate;
17 | 
18 | import java.util.*;
19 | import java.util.concurrent.TimeUnit;
20 | 
21 | @SpringBootTest
22 | class RootGetApplicationTests {
23 |     @Autowired
24 |     private AccountMapper accountMapper;
25 |     @Autowired
26 |     private VideoMapper videoMapper;
27 |     @Autowired
28 |     private CommentMapper commentMapper;
29 |     @Autowired
30 |     private StringRedisTemplate stringRedisTemplate;
31 |     @Autowired
32 |     private RedisTools redisTools;
33 |     @Autowired
34 |     private ScheduleConfig scheduleConfig;
35 |     @Autowired
36 |     private CollectionMapper collectionMapper;
37 |     @Test
38 |     void contextLoads(){
39 |         
40 |     }
41 | 
42 | }


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/filter/Interceptor.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.filter;
 2 | 
 3 | import com.lingyi.RootGet.tools.Constant;
 4 | import com.lingyi.RootGet.tools.RedisTools;
 5 | import org.springframework.beans.factory.annotation.Autowired;
 6 | import org.springframework.stereotype.Component;
 7 | import org.springframework.util.StringUtils;
 8 | import org.springframework.web.servlet.HandlerInterceptor;
 9 | 
10 | import javax.servlet.http.HttpServletRequest;
11 | import javax.servlet.http.HttpServletResponse;
12 | 
13 | @Component
14 | public class Interceptor implements HandlerInterceptor {
15 |     private final RedisTools redisTools;
16 | 
17 |     @Autowired
18 |     public Interceptor(RedisTools redisTools) {
19 |         this.redisTools = redisTools;
20 |     }
21 | 
22 |     @Override
23 |     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
24 |         String uid = Constant.getUidInCookie(request);
25 |         String token = Constant.getTokenInCookie(request);
26 |         //判断这两项是否为空
27 |         if (!StringUtils.hasText(uid) || !StringUtils.hasText(token)) {
28 |             response.setStatus(401);
29 |             return false;
30 |         }
31 |         //判断redis中的token是否和cookie中的一致
32 |         String accountToken = redisTools.getAccountToken(Long.parseLong(uid));
33 |         if (!StringUtils.hasText(accountToken) || !token.equals(accountToken)) {
34 |             response.setStatus(401);
35 |             return false;
36 |         }
37 |         return true;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/main/resources/mybatis/mappers/video/AccountMapper.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE mapper
 3 |         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4 |         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 | <mapper namespace="com.lingyi.RootGet.mapper.video.AccountMapper">
 6 |     <!--    查一个-->
 7 |     <select id="selectOneById" parameterType="long" resultType="com.lingyi.RootGet.entry.Account">
 8 |         SELECT id, name, password, createTime, banned
 9 |         FROM account
10 |         WHERE id = #{id};
11 |     </select>
12 |     <!--    关键字查找-->
13 |     <select id="selectByKeywords" parameterType="string" resultType="com.lingyi.RootGet.entry.Account">
14 |         SELECT id, name, password, createTime, banned
15 |         FROM account
16 |         WHERE name like CONCAT('%', #{name}, '%');
17 |     </select>
18 |     <!--    添加一个-->
19 |     <insert id="addOne" parameterType="com.lingyi.RootGet.entry.Account" keyProperty="id" useGeneratedKeys="true">
20 |         INSERT INTO account (name, password)
21 |         VALUES (#{name}, #{password});
22 |     </insert>
23 |     <!--    更新一个-->
24 |     <update id="updateOne" parameterType="com.lingyi.RootGet.entry.Account">
25 |         UPDATE account
26 |         <set>
27 |             <if test="name != null">
28 |                 name = #{name},
29 |             </if>
30 |             <if test="password != null">
31 |                 password = #{password},
32 |             </if>
33 |             banned = #{banned}
34 |         </set>
35 |         WHERE id = #{id};
36 |     </update>
37 | </mapper>


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/entry/Info.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.entry;
 2 | 
 3 | public class Info {
 4 |     private String name,url,imageUrl,date,detail,main;
 5 | 
 6 |     public String getName() {
 7 |         return name;
 8 |     }
 9 | 
10 |     public void setName(String name) {
11 |         this.name = name;
12 |     }
13 | 
14 |     public String getUrl() {
15 |         return url;
16 |     }
17 | 
18 |     public void setUrl(String url) {
19 |         this.url = url;
20 |     }
21 | 
22 |     public String getImageUrl() {
23 |         return imageUrl;
24 |     }
25 | 
26 |     public void setImageUrl(String imageUrl) {
27 |         this.imageUrl = imageUrl;
28 |     }
29 | 
30 |     public String getDate() {
31 |         return date;
32 |     }
33 | 
34 |     public void setDate(String date) {
35 |         this.date = date;
36 |     }
37 | 
38 |     public String getDetail() {
39 |         return detail;
40 |     }
41 | 
42 |     public void setDetail(String detail) {
43 |         this.detail = detail;
44 |     }
45 | 
46 |     public String getMain() {
47 |         return main;
48 |     }
49 | 
50 |     public void setMain(String main) {
51 |         this.main = main;
52 |     }
53 | 
54 |     @Override
55 |     public String toString() {
56 |         return "Info{" +
57 |                 "name='" + name + '\'' +
58 |                 ", url='" + url + '\'' +
59 |                 ", imageUrl='" + imageUrl + '\'' +
60 |                 ", date='" + date + '\'' +
61 |                 ", detail='" + detail + '\'' +
62 |                 ", main='" + main + '\'' +
63 |                 '}';
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 | 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4 | 	<modelVersion>4.0.0</modelVersion>
 5 | 	<parent>
 6 | 		<groupId>org.springframework.boot</groupId>
 7 | 		<artifactId>spring-boot-starter-parent</artifactId>
 8 | 		<version>2.7.1</version>
 9 | 		<relativePath/> <!-- lookup parent from repository -->
10 | 	</parent>
11 | 	<groupId>com.lingyi</groupId>
12 | 	<artifactId>RootGet</artifactId>
13 | 	<version>0.0.1-SNAPSHOT</version>
14 | 	<name>RootGet</name>
15 | 	<description>Demo project for Spring Boot</description>
16 | 	<properties>
17 | 		<java.version>11</java.version>
18 | 	</properties>
19 | 	<dependencies>
20 | 		<dependency>
21 | 			<groupId>org.springframework.boot</groupId>
22 | 			<artifactId>spring-boot-starter-web</artifactId>
23 | 		</dependency>
24 | 		<dependency>
25 | 			<groupId>mysql</groupId>
26 | 			<artifactId>mysql-connector-java</artifactId>
27 | 			<scope>runtime</scope>
28 | 		</dependency>
29 | 		<dependency>
30 | 			<groupId>org.mybatis.spring.boot</groupId>
31 | 			<artifactId>mybatis-spring-boot-starter</artifactId>
32 | 			<version>2.2.2</version>
33 | 		</dependency>
34 | 		<dependency>
35 | 			<groupId>org.springframework.boot</groupId>
36 | 			<artifactId>spring-boot-starter-data-redis</artifactId>
37 | 			<version>2.7.0</version>
38 | 		</dependency>
39 | 		<dependency>
40 | 			<groupId>eu.bitwalker</groupId>
41 | 			<artifactId>UserAgentUtils</artifactId>
42 | 			<version>1.21</version>
43 | 		</dependency>
44 | 		<dependency>
45 | 			<groupId>org.springframework.boot</groupId>
46 | 			<artifactId>spring-boot-starter-test</artifactId>
47 | 			<scope>test</scope>
48 | 		</dependency>
49 | 	</dependencies>
50 | 
51 | 	<build>
52 | 		<plugins>
53 | 			<plugin>
54 | 				<groupId>org.springframework.boot</groupId>
55 | 				<artifactId>spring-boot-maven-plugin</artifactId>
56 | 			</plugin>
57 | 		</plugins>
58 | 	</build>
59 | 
60 | </project>
61 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/Viewer.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.controller;
 2 | 
 3 | import com.lingyi.RootGet.entry.Account;
 4 | import com.lingyi.RootGet.entry.Video;
 5 | import com.lingyi.RootGet.mapper.web.InfoMapper;
 6 | import com.lingyi.RootGet.mapper.web.WordsMapper;
 7 | import com.lingyi.RootGet.entry.Info;
 8 | import com.lingyi.RootGet.entry.Words;
 9 | 
10 | import com.lingyi.RootGet.tools.RedisTools;
11 | import org.springframework.beans.factory.annotation.Autowired;
12 | import org.springframework.stereotype.Controller;
13 | 
14 | import org.springframework.web.bind.annotation.*;
15 | 
16 | import javax.servlet.http.HttpServletRequest;
17 | 
18 | import java.util.List;
19 | 
20 | /**
21 |  * 这个是类与此项目无关 up自用的，懒得删
22 |  **/
23 | @Controller
24 | public class Viewer {
25 |     private final InfoMapper infoMapper;
26 |     private final WordsMapper wordsMapper;
27 |     private final RedisTools redisTools;
28 | 
29 |     @Autowired
30 |     public Viewer(InfoMapper infoMapper, WordsMapper wordsMapper, RedisTools redisTools) {
31 |         this.infoMapper = infoMapper;
32 |         this.wordsMapper = wordsMapper;
33 |         this.redisTools = redisTools;
34 |     }
35 | 
36 |     @RequestMapping("/getWebs")
37 |     @ResponseBody
38 |     public List getWebs() {
39 |         List<Info> info = infoMapper.getInfo();
40 |         return info;
41 |     }
42 | 
43 |     @RequestMapping("/getWords")
44 |     @ResponseBody
45 |     public List<Words> getWords() {
46 |         return wordsMapper.getWords();
47 |     }
48 | 
49 |     @RequestMapping("/Video/{id}")
50 |     public String getVideo(@PathVariable("id") String id) {
51 |         Video video = redisTools.selectVideoInCache(id);
52 |         if (video == null) return null;
53 |             redisTools.addOnePlay(id);
54 |         return "/video/index.html";
55 |     }
56 | 
57 |     @RequestMapping("/Mine/{id}")
58 |     public String mine(@PathVariable("id") String id) {
59 |         long uid = Long.parseLong(id);
60 |         Account account = redisTools.selectAccountInCache(uid);
61 |         if(account==null) return null;
62 |         return "/mine/index.html";
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/entry/Account.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.entry;
 2 | 
 3 | import com.lingyi.RootGet.tools.Constant;
 4 | import org.springframework.util.StringUtils;
 5 | 
 6 | public class Account {
 7 |     private int banned;
 8 |     private long id, createTime_long;
 9 |     private String name, password, createTime;
10 | 
11 |     public long getId() {
12 |         return id;
13 |     }
14 | 
15 |     public Account setId(long id) {
16 |         this.id = id;
17 |         return this;
18 |     }
19 | 
20 |     public int getBanned() {
21 |         return banned;
22 |     }
23 | 
24 |     public void setBanned(int banned) {
25 |         this.banned = banned;
26 |     }
27 | 
28 |     public long getCreateTime_long() {
29 |         if (createTime_long == 0L&& StringUtils.hasText(createTime))
30 |             createTime_long = Constant.StringParseToLong(createTime);
31 |         return createTime_long;
32 |     }
33 | 
34 |     public Account setCreateTime_long(long createTime_long) {
35 |         this.createTime_long = createTime_long;
36 |         return this;
37 |     }
38 | 
39 |     public String getName() {
40 |         return name;
41 |     }
42 | 
43 |     public Account setName(String name) {
44 |         this.name = name;
45 |         return this;
46 |     }
47 | 
48 |     public String getPassword() {
49 |         return password;
50 |     }
51 | 
52 |     public Account setPassword(String password) {
53 |         this.password = password;
54 |         return this;
55 |     }
56 | 
57 |     public String getCreateTime() {
58 |         return createTime;
59 |     }
60 | 
61 |     public Account setCreateTime(String createTime) {
62 |         this.createTime = createTime;
63 |         return this;
64 |     }
65 | 
66 |     @Override
67 |     public String toString() {
68 |         return "Account{" +
69 |                 "banned=" + banned +
70 |                 ", id=" + id +
71 |                 ", createTime_long=" + createTime_long +
72 |                 ", name='" + name + '\'' +
73 |                 ", password='" + password + '\'' +
74 |                 ", createTime='" + createTime + '\'' +
75 |                 '}';
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/datasource/web/DataSourceConfigWeb.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.datasource.web;
 2 | 
 3 | import org.apache.ibatis.session.SqlSessionFactory;
 4 | import org.mybatis.spring.SqlSessionFactoryBean;
 5 | import org.mybatis.spring.SqlSessionTemplate;
 6 | import org.mybatis.spring.annotation.MapperScan;
 7 | import org.springframework.beans.factory.annotation.Qualifier;
 8 | import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
 9 | import org.springframework.boot.context.properties.ConfigurationProperties;
10 | import org.springframework.context.annotation.Bean;
11 | import org.springframework.context.annotation.Configuration;
12 | import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
13 | 
14 | import javax.sql.DataSource;
15 | 
16 | /**
17 |  * 这个数据源与此项目无关，懒得删，相应的mapper.xml也是同理
18 |  */
19 | 
20 | @Configuration
21 | @MapperScan(value = "com.lingyi.RootGet.mapper.web",sqlSessionFactoryRef = "sqlSessionFactoryWeb")
22 | public class DataSourceConfigWeb {
23 |     @Bean
24 |     @ConfigurationProperties(prefix = "spring.datasource.web")
25 |     public DataSourceProperties dataSourcePropertiesWeb(){
26 |         return new DataSourceProperties();
27 |     }
28 |     @Bean
29 |     public DataSource dataSourceWeb(@Qualifier("dataSourcePropertiesWeb")DataSourceProperties dataSourcePropertiesWeb){
30 |         return  dataSourcePropertiesWeb.initializeDataSourceBuilder().build();
31 |     }
32 |     @Bean
33 |     public SqlSessionFactory sqlSessionFactoryWeb(@Qualifier("dataSourceWeb")DataSource dataSourceWeb) throws Exception {
34 |         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
35 |         sqlSessionFactoryBean.setDataSource(dataSourceWeb);
36 |         PathMatchingResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver();
37 |         sqlSessionFactoryBean.setMapperLocations(patternResolver.getResource("classpath:mybatis/mappers/web/InfoMapper.xml"), patternResolver.getResource("classpath:mybatis/mappers/web/WordsMapper.xml"));
38 |         return sqlSessionFactoryBean.getObject();
39 |     }
40 |     @Bean
41 |     public SqlSessionTemplate sqlSessionTemplateWeb(@Qualifier("sqlSessionFactoryWeb")SqlSessionFactory sqlSessionFactoryWeb){
42 |         return new SqlSessionTemplate(sqlSessionFactoryWeb);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/main/resources/logback.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <configuration>
 3 |     <property name="path" value="/log/videoStation"/>
 4 |     <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c %M %L [%thread] %m%n"/>
 5 | <!--    输出文件-->
 6 |     <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
 7 |         <file>${path}/video-logback.log</file>
 8 |         <encoder  class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 9 |             <pattern>${pattern}</pattern>
10 |         </encoder>
11 |         <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
12 |             <!--%d{yyyy-MM-dd}引用日期，%i表示拆分后的文件序号-->
13 |             <fileNamePattern>${file_path}/%d{yyyy-MM-dd}-%i.log</fileNamePattern>
14 |             <maxFileSize>10MB</maxFileSize>
15 |         </rollingPolicy>
16 |         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
17 |             <level>ERROR</level>
18 |         </filter>
19 |     </appender>
20 |     <!--控制台输出-->
21 |     <appender name="console_info" class="ch.qos.logback.core.ConsoleAppender">
22 |         <target>System.out</target>
23 |         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
24 |             <pattern>${pattern}</pattern>
25 |         </encoder>
26 |         <filter class="ch.qos.logback.classic.filter.LevelFilter">
27 |             <level>INFO</level>
28 |             <onMatch>ACCEPT</onMatch>
29 |             <onMismatch>DENY</onMismatch>
30 |         </filter>
31 |     </appender>
32 |     <appender name="console_error" class="ch.qos.logback.core.ConsoleAppender">
33 |         <target>System.err</target>
34 |         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
35 |             <pattern>${pattern}</pattern>
36 |         </encoder>
37 |         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
38 |             <level>WARN</level>
39 |         </filter>
40 |     </appender>
41 | <!--    异步-->
42 |     <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
43 |         <!--指定某一个appender-->
44 |         <appender-ref ref="file"/>
45 |     </appender>
46 |     <logger name="videoLog" level="ALL" additivity="true">
47 |         <appender-ref ref="async"/>
48 |     </logger>
49 |     <root level="INFO">
50 |         <appender-ref ref="console_info"/>
51 |         <appender-ref ref="console_error"/>
52 |     </root>
53 | </configuration>


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/datasource/video/DataSourceConfigVideo.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.datasource.video;
 2 | 
 3 | import org.apache.ibatis.session.SqlSessionFactory;
 4 | import org.mybatis.spring.SqlSessionFactoryBean;
 5 | import org.mybatis.spring.SqlSessionTemplate;
 6 | import org.mybatis.spring.annotation.MapperScan;
 7 | import org.springframework.beans.factory.annotation.Qualifier;
 8 | import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
 9 | import org.springframework.boot.context.properties.ConfigurationProperties;
10 | import org.springframework.context.annotation.Bean;
11 | import org.springframework.context.annotation.Configuration;
12 | import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
13 | 
14 | import javax.sql.DataSource;
15 | 
16 | @Configuration
17 | @MapperScan(value = "com.lingyi.RootGet.mapper.video",sqlSessionFactoryRef = "sqlSessionFactoryVideo")
18 | public class DataSourceConfigVideo {
19 |     @Bean
20 |     @ConfigurationProperties(prefix = "spring.datasource.video")
21 |     public DataSourceProperties dataSourcePropertiesVideo(){
22 |         return new DataSourceProperties();
23 |     }
24 |     @Bean
25 |     public DataSource dataSourceVideo(@Qualifier("dataSourcePropertiesVideo")DataSourceProperties dataSourcePropertiesVideo){
26 |         return dataSourcePropertiesVideo.initializeDataSourceBuilder().build();
27 |     }
28 |     @Bean
29 |     public SqlSessionFactory sqlSessionFactoryVideo(@Qualifier("dataSourceVideo")DataSource dataSourceVideo) throws Exception {
30 |         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
31 |         sqlSessionFactoryBean.setDataSource(dataSourceVideo);
32 |         PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
33 |         sqlSessionFactoryBean.setMapperLocations(
34 |                 resolver.getResource("classpath:mybatis/mappers/video/AccountMapper.xml"),
35 |                 resolver.getResource("classpath:mybatis/mappers/video/VideoMapper.xml"),
36 |                 resolver.getResource("classpath:mybatis/mappers/video/CommentMapper.xml"),
37 |                 resolver.getResource("classpath:mybatis/mappers/video/CollectionMapper.xml")
38 |                 );
39 |         return sqlSessionFactoryBean.getObject();
40 |     }
41 |     @Bean
42 |     public SqlSessionTemplate sqlSessionTemplateVideo(@Qualifier("sqlSessionFactoryVideo")SqlSessionFactory sqlSessionFactoryVideo){
43 |         return new SqlSessionTemplate(sqlSessionFactoryVideo);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/entry/Comment.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.entry;
  2 | 
  3 | import com.lingyi.RootGet.tools.Constant;
  4 | 
  5 | import java.util.List;
  6 | 
  7 | public class Comment {
  8 |     private String text,time,userName;
  9 |     private long id,uid,time_long,like,forId;
 10 |     private List<Comment> commentList;
 11 | 
 12 |     public String getText() {
 13 |         return text;
 14 |     }
 15 | 
 16 |     public Comment setText(String text) {
 17 |         this.text = text;
 18 |         return this;
 19 |     }
 20 | 
 21 |     public String getTime() {
 22 |         return time;
 23 |     }
 24 | 
 25 |     public Comment setTime(String time) {
 26 |         this.time = time;
 27 |         return this;
 28 |     }
 29 | 
 30 |     public String getUserName() {
 31 |         return userName;
 32 |     }
 33 | 
 34 |     public Comment setUserName(String userName) {
 35 |         this.userName = userName;
 36 |         return this;
 37 |     }
 38 | 
 39 |     public long getTime_long() {
 40 |         if(this.time_long==0)
 41 |             this.time_long = Constant.StringParseToLong(time);
 42 |         return time_long;
 43 |     }
 44 | 
 45 |     public Comment setTime_long(long time_long) {
 46 |         this.time_long = time_long;
 47 |         return this;
 48 |     }
 49 | 
 50 |     public long getLike() {
 51 |         return like;
 52 |     }
 53 | 
 54 |     public Comment setLike(long like) {
 55 |         this.like = like;
 56 |         return this;
 57 |     }
 58 | 
 59 |     public List<Comment> getCommentList() {
 60 |         return commentList;
 61 |     }
 62 | 
 63 |     public Comment setCommentList(List<Comment> commentList) {
 64 |         this.commentList = commentList;
 65 |         return this;
 66 |     }
 67 | 
 68 |     public long getId() {
 69 |         return id;
 70 |     }
 71 | 
 72 |     public Comment setId(long id) {
 73 |         this.id = id;
 74 |         return this;
 75 |     }
 76 | 
 77 |     public long getForId() {
 78 |         return forId;
 79 |     }
 80 | 
 81 |     public Comment setForId(long forId) {
 82 |         this.forId = forId;
 83 |         return this;
 84 |     }
 85 | 
 86 |     public long getUid() {
 87 |         return uid;
 88 |     }
 89 | 
 90 |     public Comment setUid(long uid) {
 91 |         this.uid = uid;
 92 |         return this;
 93 |     }
 94 | 
 95 |     @Override
 96 |     public String toString() {
 97 |         return "Comment{" +
 98 |                 "text='" + text + '\'' +
 99 |                 ", time='" + time + '\'' +
100 |                 ", userName='" + userName + '\'' +
101 |                 ", id=" + id +
102 |                 ", uid=" + uid +
103 |                 ", time_long=" + time_long +
104 |                 ", like=" + like +
105 |                 ", forId=" + forId +
106 |                 ", commentList=" + commentList +
107 |                 '}';
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/CollectionController.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.controller;
 2 | 
 3 | import com.lingyi.RootGet.entry.Collection;
 4 | import com.lingyi.RootGet.tools.Constant;
 5 | import com.lingyi.RootGet.tools.RedisTools;
 6 | import org.springframework.web.bind.annotation.*;
 7 | 
 8 | import javax.servlet.http.HttpServletRequest;
 9 | import javax.servlet.http.HttpServletResponse;
10 | import java.util.List;
11 | import java.util.Map;
12 | 
13 | @RestController
14 | @RequestMapping("/api/collection")
15 | public class CollectionController {
16 |     private final RedisTools redisTools;
17 |     public CollectionController(RedisTools redisTools){
18 |         this.redisTools = redisTools;
19 |     }
20 |     @GetMapping("/getCollectionByUid/{uid}")
21 |     public List<Collection> getCollection(@PathVariable("uid")long uid){
22 |         return redisTools.getCollection(uid);
23 |     }
24 |     @PostMapping("/addToCollection")
25 |     public String addToCollection(@RequestBody Map<String,String> body,HttpServletRequest request){
26 |         long id = Long.parseLong(body.get("id"));
27 |         String name = body.get("name");
28 |         long videoId = Long.parseLong(body.get("videoId"));
29 |         String uidInCookie = Constant.getUidInCookie(request);
30 |         if(uidInCookie==null||id!=Long.parseLong(uidInCookie)) return Constant.NoPermission;
31 |         redisTools.addToCollection(id,videoId,name);
32 |         return Constant.SUCCESS;
33 |     }
34 |     @PostMapping("/removeFromCollection")
35 |     public String removeFromCollection(@RequestBody Map<String,String> body, HttpServletRequest request){
36 |         long id = Long.parseLong(body.get("id"));
37 |         String name = body.get("name");
38 |         long videoId = Long.parseLong(body.get("videoId"));
39 |         String uidInCookie = Constant.getUidInCookie(request);
40 |         if(uidInCookie==null||id!=Long.parseLong(uidInCookie)) return Constant.NoPermission;
41 |         redisTools.removeFromCollection(id,videoId,name);
42 |         return Constant.SUCCESS;
43 |     }
44 |     @PostMapping("/renameCollection")
45 |     public String rename(@RequestBody Map<String,String> body, HttpServletRequest request){
46 |         long id = Long.parseLong(body.get("id"));
47 |         String name = body.get("name");
48 |         String newName = body.get("newName");
49 |         if(name.equals(newName)) return Constant.KeyExists;
50 |                 String uidInCookie = Constant.getUidInCookie(request);
51 |         if(uidInCookie==null||id!=Long.parseLong(uidInCookie)) return Constant.NoPermission;
52 |         Boolean hasKey = redisTools.getRedisTemplate().hasKey("VideoStation:Collection:"+id+ ":"+ newName);
53 |         if(hasKey) return Constant.KeyExists;
54 |         redisTools.renameKey("VideoStation:Collection:"+id+":"+name,"VideoStation:Collection:"+id+":"+newName);
55 |         return Constant.SUCCESS;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/entry/Video.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.entry;
  2 | 
  3 | import com.lingyi.RootGet.tools.Constant;
  4 | import org.springframework.util.StringUtils;
  5 | 
  6 | public class Video {
  7 |     private String id,title,summary,time,upName;
  8 |     private long up,time_long,like,collection,play;
  9 | 
 10 |     public long getPlay() {
 11 |         return play;
 12 |     }
 13 | 
 14 |     public Video setPlay(long play) {
 15 |         this.play = play;
 16 |         return this;
 17 |     }
 18 | 
 19 |     public String getUpName() {
 20 |         return upName;
 21 |     }
 22 | 
 23 |     public Video setUpName(String upName) {
 24 |         this.upName = upName;
 25 |         return this;
 26 |     }
 27 | 
 28 |     public String getTitle() {
 29 |         return title;
 30 |     }
 31 | 
 32 |     public Video setTitle(String title) {
 33 |         this.title = title;
 34 |         return this;
 35 |     }
 36 | 
 37 |     public String getSummary() {
 38 |         return summary;
 39 |     }
 40 | 
 41 |     public Video setSummary(String summary) {
 42 |         this.summary = summary;
 43 |         return this;
 44 |     }
 45 | 
 46 |     public String getTime() {
 47 |         return time;
 48 |     }
 49 | 
 50 |     public Video setTime(String time) {
 51 |         this.time = time;
 52 |         return this;
 53 |     }
 54 | 
 55 |     public String getId() {
 56 |         return id;
 57 |     }
 58 | 
 59 |     public Video setId(String id) {
 60 |         this.id = id;
 61 |         return this;
 62 |     }
 63 | 
 64 |     public long getUp() {
 65 |         return up;
 66 |     }
 67 | 
 68 |     public Video setUp(long up) {
 69 |         this.up = up;
 70 |         return this;
 71 |     }
 72 | 
 73 |     public long getTime_long() {
 74 |         if(time_long==0L&& StringUtils.hasText(time))
 75 |             time_long = Constant.StringParseToLong(time);
 76 |         return time_long;
 77 |     }
 78 | 
 79 |     public Video setTime_long(long time_long) {
 80 |         this.time_long = time_long;
 81 |         return this;
 82 |     }
 83 | 
 84 |     public long getLike() {
 85 |         return like;
 86 |     }
 87 | 
 88 |     public Video setLike(long like) {
 89 |         this.like = like;
 90 |         return this;
 91 |     }
 92 | 
 93 |     public long getCollection() {
 94 |         return collection;
 95 |     }
 96 | 
 97 |     public Video setCollection(long collection) {
 98 |         this.collection = collection;
 99 |         return this;
100 |     }
101 | 
102 |     @Override
103 |     public String toString() {
104 |         return "Video{" +
105 |                 "title='" + title + '\'' +
106 |                 ", summary='" + summary + '\'' +
107 |                 ", time='" + time + '\'' +
108 |                 ", upName='" + upName + '\'' +
109 |                 ", id=" + id +
110 |                 ", up=" + up +
111 |                 ", time_long=" + time_long +
112 |                 ", like=" + like +
113 |                 ", collection=" + collection +
114 |                 ", play=" + play +
115 |                 '}';
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/tools/SnowFlake.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.tools;
  2 | 
  3 | public class SnowFlake {
  4 |     /** 开始时间截 (这个用自己业务系统上线的时间) */
  5 |     private final long twepoch = 1575365018000L;
  6 | 
  7 |     /** 机器id所占的位数 */
  8 |     private final long workerIdBits = 10L;
  9 | 
 10 |     /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
 11 |     private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
 12 | 
 13 |     /** 序列在id中占的位数 */
 14 |     private final long sequenceBits = 12L;
 15 | 
 16 |     /** 机器ID向左移12位 */
 17 |     private final long workerIdShift = sequenceBits;
 18 | 
 19 |     /** 时间截向左移22位(10+12) */
 20 |     private final long timestampLeftShift = sequenceBits + workerIdBits;
 21 | 
 22 |     /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
 23 |     private final long sequenceMask = -1L ^ (-1L << sequenceBits);
 24 | 
 25 |     /** 工作机器ID(0~1024) */
 26 |     private long workerId;
 27 | 
 28 |     /** 毫秒内序列(0~4095) */
 29 |     private long sequence = 0L;
 30 | 
 31 |     /** 上次生成ID的时间截 */
 32 |     private long lastTimestamp = -1L;
 33 | 
 34 |     //==============================Constructors=====================================
 35 |     /**
 36 |      * 构造函数
 37 |      * @param workerId 工作ID (0~1024)
 38 |      */
 39 |     public SnowFlake(long workerId) {
 40 |         if (workerId > maxWorkerId || workerId < 0) {
 41 |             throw new IllegalArgumentException(String.format("workerId can't be greater than %d or less than 0", maxWorkerId));
 42 |         }
 43 |         this.workerId = workerId;
 44 |     }
 45 | 
 46 |     // ==============================Methods==========================================
 47 |     /**
 48 |      * 获得下一个ID (该方法是线程安全的)
 49 |      * @return SnowflakeId
 50 |      */
 51 |     public synchronized long nextId() {
 52 |         long timestamp = timeGen();
 53 | 
 54 |         //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
 55 |         if (timestamp < lastTimestamp) {
 56 |             throw new RuntimeException(
 57 |                     String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
 58 |         }
 59 | 
 60 |         //如果是同一时间生成的，则进行毫秒内序列
 61 |         if (lastTimestamp == timestamp) {
 62 |             sequence = (sequence + 1) & sequenceMask;
 63 |             //毫秒内序列溢出
 64 |             if (sequence == 0) {
 65 |                 //阻塞到下一个毫秒,获得新的时间戳
 66 |                 timestamp = tilNextMillis(lastTimestamp);
 67 |             }
 68 |         }
 69 |         //时间戳改变，毫秒内序列重置
 70 |         else {
 71 |             sequence = 0L;
 72 |         }
 73 | 
 74 |         //上次生成ID的时间截
 75 |         lastTimestamp = timestamp;
 76 | 
 77 |         //移位并通过或运算拼到一起组成64位的ID
 78 |         return ((timestamp - twepoch) << timestampLeftShift) //
 79 |                 | (workerId << workerIdShift) //
 80 |                 | sequence;
 81 |     }
 82 | 
 83 |     /**
 84 |      * 阻塞到下一个毫秒，直到获得新的时间戳
 85 |      * @param lastTimestamp 上次生成ID的时间截
 86 |      * @return 当前时间戳
 87 |      */
 88 |     protected long tilNextMillis(long lastTimestamp) {
 89 |         long timestamp = timeGen();
 90 |         while (timestamp <= lastTimestamp) {
 91 |             timestamp = timeGen();
 92 |         }
 93 |         return timestamp;
 94 |     }
 95 | 
 96 |     /**
 97 |      * 返回以毫秒为单位的当前时间
 98 |      * @return 当前时间(毫秒)
 99 |      */
100 |     protected long timeGen() {
101 |         return System.currentTimeMillis();
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/main/resources/mybatis/mappers/video/VideoMapper.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE mapper
 3 |         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4 |         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 | <mapper namespace="com.lingyi.RootGet.mapper.video.VideoMapper">
 6 |     <select id="selectAll" resultType="com.lingyi.RootGet.entry.Video">
 7 |         SELECT id, title, summary, time, up, `like`, collection,upName,play
 8 |         FROM video
 9 |     </select>
10 |     <!--    表中是否存在数据-->
11 |     <select id="isExists" parameterType="string" resultType="boolean">
12 |         SELECT IFNULL((SELECT TRUE FROM video WHERE id = #{id} LIMIT 1),FALSE);
13 |     </select>
14 |     <!--    查询一个-->
15 |     <select id="selectOneById" parameterType="string" resultType="com.lingyi.RootGet.entry.Video">
16 |         SELECT id, title, summary, time, up, `like`, collection,upName,play
17 |         FROM video
18 |         WHERE id = #{id};
19 |     </select>
20 |     <!--    关键词搜索-->
21 |     <select id="selectByKeywords" parameterType="string" resultType="com.lingyi.RootGet.entry.Video">
22 |         SELECT id, title, summary, time, up, `like`, collection,upName,play
23 |         FROM video
24 |         WHERE title like CONCAT('%', #{title}, '%');
25 |     </select>
26 |     <!--    关键词搜索-->
27 |     <select id="selectByUp" parameterType="long" resultType="com.lingyi.RootGet.entry.Video">
28 |         SELECT id, title, summary, time, up, `like`, collection,upName,play
29 |         FROM video
30 |         WHERE up = #{up};
31 |     </select>
32 |     <!--    添加一个-->
33 |     <insert id="addOne" parameterType="com.lingyi.RootGet.entry.Video">
34 |         INSERT INTO video (id, title, summary, up,upName,collection,play)
35 |         VALUES (#{id}, #{title}, #{summary}, #{up},#{upName},#{collection},#{play});
36 |     </insert>
37 |     <!--    添加多个-->
38 |     <insert id="addVideos" parameterType="list">
39 |         <foreach collection="list" item="item" separator=";">
40 |             INSERT INTO video(id, title, summary, up,upName,collection,play)
41 |             VALUES (#{item.id}, #{item.title}, #{item.summary}, #{item.up},#{item.collection},#{item.play})
42 |         </foreach>
43 |     </insert>
44 |     <!--    更新一个-->
45 |     <update id="updateOne" parameterType="com.lingyi.RootGet.entry.Video">
46 |         UPDATE video
47 |         <set>
48 |             <if test="title != null">
49 |                 title = #{title},
50 |             </if>
51 |             <if test="summary != null">
52 |                 summary = #{summary},
53 |             </if>
54 |             <if test="up != null">
55 |                 up = #{up},
56 |             </if>
57 |                 `like` = #{like},
58 |                 collection = #{collection},
59 |                 play = #{play}
60 |         </set>
61 |         WHERE id = #{id}
62 |     </update>
63 |     <!--    更新多个-->
64 |     <update id="updateVideos" parameterType="list">
65 |         <foreach collection="list" item="item" separator=";">
66 |             UPDATE video
67 |             <set>
68 |                 <if test="item.title != null">
69 |                     title = #{item.title},
70 |                 </if>
71 |                 <if test="item.summary != null">
72 |                     summary = #{item.summary},
73 |                 </if>
74 |                 <if test="item.up != null">
75 |                     up = #{item.up},
76 |                 </if>
77 |                     `like` = #{item.like},
78 |                     collection = #{item.collection},
79 |                     play = #{item.play}
80 |             </set>
81 |             WHERE id = #{item.id}
82 |         </foreach>
83 |     </update>
84 |     <delete id="deleteOne" parameterType="string">
85 |         DELETE FROM video WHERE id = #{id};
86 |     </delete>
87 |     <update id="updateUpName" parameterType="string">
88 |         UPDATE video SET upName = #{newName} WHERE upName = #{oldName};
89 |     </update>
90 | </mapper>


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/config/ScheduleConfig.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.config;
  2 | 
  3 | import com.fasterxml.jackson.core.JsonProcessingException;
  4 | import com.fasterxml.jackson.databind.ObjectMapper;
  5 | import com.lingyi.RootGet.entry.Video;
  6 | import com.lingyi.RootGet.mapper.video.CollectionMapper;
  7 | import com.lingyi.RootGet.mapper.video.VideoMapper;
  8 | import com.lingyi.RootGet.tools.RedisTools;
  9 | import org.springframework.context.annotation.Configuration;
 10 | import org.springframework.scheduling.annotation.EnableScheduling;
 11 | import org.springframework.scheduling.annotation.Scheduled;
 12 | 
 13 | import java.util.*;
 14 | 
 15 | @Configuration
 16 | @EnableScheduling
 17 | public class ScheduleConfig {
 18 |     private final RedisTools redisTools;
 19 |     private final VideoMapper videoMapper;
 20 |     private final CollectionMapper collectionMapper;
 21 |     private final ObjectMapper objectMapper;
 22 | 
 23 |     public ScheduleConfig(RedisTools redisTools, VideoMapper videoMapper, CollectionMapper collectionMapper, ObjectMapper objectMapper) {
 24 |         this.redisTools = redisTools;
 25 |         this.videoMapper = videoMapper;
 26 |         this.collectionMapper = collectionMapper;
 27 |         this.objectMapper = objectMapper;
 28 |     }
 29 | 
 30 |     @Scheduled(cron = "0 0 23 * * ?")
 31 |     public void sync() throws JsonProcessingException {
 32 |         syncVideo();
 33 |         syncCollection();
 34 |     }
 35 | 
 36 |     private void syncVideo() {
 37 |         List<Video> list = new ArrayList<>();
 38 |         List<Video> exists = new ArrayList<>();
 39 |         List<Video> notExists = new ArrayList<>();
 40 |         //获取所有id
 41 |         Set<String> keys = redisTools.getKeys("VideoStation:Video:*");
 42 | 
 43 |         if (keys == null || keys.isEmpty()) return;
 44 |         //redis中获取视频
 45 |         for (String key : keys) {
 46 |             Video video = redisTools.getFromHashAsObject(key, Video.class);
 47 |             list.add(video);
 48 |         }
 49 |         //所有添加到list
 50 |         for (Video video : list) {
 51 |             if (videoMapper.isExists(video.getId()))
 52 |                 exists.add(video);
 53 |             else notExists.add(video);
 54 |         }
 55 | 
 56 |         if (!exists.isEmpty())
 57 |             videoMapper.updateVideos(exists);
 58 |         if (!notExists.isEmpty())
 59 |             videoMapper.addVideos(notExists);
 60 | 
 61 |         //清除
 62 |         list.clear();
 63 |         exists.clear();
 64 |         notExists.clear();
 65 |     }
 66 | 
 67 |     public void syncCollection() throws JsonProcessingException {
 68 |         Map<String, String> exists_collection = new HashMap<>();
 69 |         Map<String, String> notExists_collection = new HashMap<>();
 70 | 
 71 |         List<String> noLongerUse = new ArrayList<>();
 72 | 
 73 |         //获取所有id
 74 |         Set<String> keys = redisTools.getKeys("VideoStation:Collection:*");
 75 |         if (keys == null || keys.isEmpty()) return;
 76 | 
 77 |         //所有添加到list
 78 |         for (String key : keys) {
 79 |             Set<String> set = redisTools.getRedisTemplate().opsForSet().members(key);
 80 |             String json = objectMapper.writeValueAsString(set);
 81 |             if (collectionMapper.isExists(key))
 82 |                 exists_collection.put(key, json);
 83 |             else
 84 |                 notExists_collection.put(key, json);
 85 |         }
 86 | 
 87 |         if (!exists_collection.isEmpty())
 88 |             collectionMapper.updateCollections(exists_collection);
 89 |         if (!notExists_collection.isEmpty())
 90 |             collectionMapper.addCollections(notExists_collection);
 91 | 
 92 |         Map<String, Object> selectAll = collectionMapper.selectAll();
 93 |         for (String key : selectAll.keySet()) {
 94 |             if (!keys.contains(key)){
 95 |                 noLongerUse.add(key);
 96 |             }
 97 |         }
 98 | 
 99 |         collectionMapper.delete(noLongerUse);
100 | 
101 |         //清除
102 |         exists_collection.clear();
103 |         notExists_collection.clear();
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/CommentController.java:
--------------------------------------------------------------------------------
 1 | package com.lingyi.RootGet.controller;
 2 | 
 3 | import com.lingyi.RootGet.entry.Comment;
 4 | import com.lingyi.RootGet.entry.Danmaku;
 5 | import com.lingyi.RootGet.mapper.video.CommentMapper;
 6 | import com.lingyi.RootGet.tools.Constant;
 7 | import org.springframework.web.bind.annotation.*;
 8 | import org.w3c.dom.Document;
 9 | import org.w3c.dom.NamedNodeMap;
10 | import org.w3c.dom.Node;
11 | import org.w3c.dom.NodeList;
12 | import org.xml.sax.SAXException;
13 | 
14 | import javax.servlet.http.HttpServletRequest;
15 | import javax.servlet.http.HttpServletResponse;
16 | import javax.xml.parsers.DocumentBuilder;
17 | import javax.xml.parsers.DocumentBuilderFactory;
18 | import javax.xml.parsers.ParserConfigurationException;
19 | import java.io.File;
20 | import java.io.IOException;
21 | import java.util.ArrayList;
22 | import java.util.List;
23 | 
24 | @RestController
25 | @RequestMapping("/api/comments")
26 | public class CommentController {
27 |     private final CommentMapper commentMapper;
28 | 
29 |     public CommentController(CommentMapper commentMapper) {
30 |         this.commentMapper = commentMapper;
31 |     }
32 | 
33 |     @GetMapping("/getComments/{id}")
34 |     public List<Comment> getComments(@PathVariable("id") long id) {
35 |         List<Comment> comments = commentMapper.getCommentsByForId(id);
36 |         for (Comment comment : comments) {
37 |             List<Comment> list = commentMapper.getCommentsByForId(comment.getId());
38 |             comment.setCommentList(list);
39 |         }
40 |         return comments;
41 |     }
42 | 
43 |     @PostMapping("/addComment")
44 |     public String addComment(@RequestBody Comment comment) {
45 |         ArrayList<String> forbiddenWords = Constant.getForbiddenWords();
46 |         for (String forbiddenWord : forbiddenWords) {
47 |             if (comment.getText().contains(forbiddenWord))
48 |                 return Constant.WordsForbidden;
49 |         }
50 |         int result = commentMapper.addComment(comment);
51 |         if (result != 1) return Constant.FAILURE;
52 |         return Constant.SUCCESS;
53 |     }
54 | 
55 |     @PostMapping("/deleteComment")
56 |     public String deleteComment(@RequestBody Comment comment, HttpServletRequest request) {
57 |         String uid = Constant.getUidInCookie(request);
58 |         if (uid == null || comment.getUid() != Long.parseLong(uid)) return Constant.NoPermission;
59 |         int result = commentMapper.deleteComment(comment);
60 |         if (result != 1) return Constant.FAILURE;
61 |         return Constant.SUCCESS;
62 |     }
63 |     @GetMapping("/getDanmaku/v3")
64 |     public Danmaku get(@RequestParam("id")long id, HttpServletResponse response) throws ParserConfigurationException, IOException, SAXException {
65 |         Danmaku danmaku = new Danmaku();
66 |         List<List<String>> data = new ArrayList<>();
67 |         File file = new File("/opt/Server/videoStation/danmaku/"+id+".xml");
68 |         if(!file.exists()){
69 |             response.setStatus(503);
70 |             return null;
71 |         }
72 |         DocumentBuilderFactory factory = DocumentBuilderFactory.newDefaultInstance();
73 |         DocumentBuilder builder = factory.newDocumentBuilder();
74 |         Document document = builder.parse(file);
75 |         NodeList nodeList = document.getElementsByTagName("d");
76 |         for(int i=0;i< nodeList.getLength();i++){
77 |             Node node = nodeList.item(i);
78 |             NamedNodeMap attributes = node.getAttributes();
79 |             Node p = attributes.getNamedItem("p");
80 |             String value = p.getNodeValue();
81 |             String[] strings = value.split(",");
82 |             List<String> list = new ArrayList<>();
83 |             list.add(strings[0]);
84 |             list.add(strings[1]);
85 |             list.add(Integer.toHexString(Integer.parseInt(strings[3])));
86 |             list.add(strings[6]);
87 |             String content = node.getTextContent();
88 |             list.add(content);
89 |             data.add(list);
90 |         }
91 |         danmaku.setData(data);
92 |         danmaku.setCode(0);
93 |         return danmaku;
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/Administrator.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.controller;
  2 | 
  3 | import com.lingyi.RootGet.entry.Account;
  4 | import com.lingyi.RootGet.entry.Video;
  5 | import com.lingyi.RootGet.mapper.video.AccountMapper;
  6 | import com.lingyi.RootGet.mapper.video.VideoMapper;
  7 | import com.lingyi.RootGet.tools.Constant;
  8 | import com.lingyi.RootGet.tools.MD5Transfer;
  9 | import com.lingyi.RootGet.tools.RedisTools;
 10 | import org.apache.tomcat.util.bcel.Const;
 11 | import org.springframework.util.StringUtils;
 12 | import org.springframework.web.bind.annotation.*;
 13 | 
 14 | import javax.servlet.http.HttpServletRequest;
 15 | import javax.servlet.http.HttpSession;
 16 | import java.io.File;
 17 | import java.util.ArrayList;
 18 | import java.util.List;
 19 | import java.util.Map;
 20 | 
 21 | @RestController
 22 | @RequestMapping("/api/admin")
 23 | public class Administrator {
 24 |     private final RedisTools redisTools;
 25 |     private final VideoMapper videoMapper;
 26 |     private final AccountMapper accountMapper;
 27 | 
 28 |     public Administrator(RedisTools redisTools, VideoMapper videoMapper, AccountMapper accountMapper) {
 29 |         this.redisTools = redisTools;
 30 |         this.videoMapper = videoMapper;
 31 |         this.accountMapper = accountMapper;
 32 |     }
 33 | 
 34 |     @PostMapping("/login")
 35 |     public String login(@RequestBody Map<String, String> body, HttpServletRequest request) {
 36 |         String id = body.get("id");
 37 |         long id_long;
 38 |         String password = body.get("password");
 39 |         if (!StringUtils.hasText(id) || !StringUtils.hasText(password))
 40 |             return Constant.NoPermission;
 41 |         try {
 42 |             id_long = Long.parseLong(id);
 43 |         } catch (Exception e) {
 44 |             return Constant.FAILURE;
 45 |         }
 46 |         if (id_long != 10063301)
 47 |             return Constant.NoPermission;
 48 |         Account account = redisTools.selectAccountInCache(id_long);
 49 |         if (!account.getPassword().equals(MD5Transfer.encode(password)))
 50 |             return Constant.PasswordIncorrect;
 51 |         HttpSession session = request.getSession();
 52 |         session.setAttribute("id", id);
 53 |         return Constant.SUCCESS;
 54 |     }
 55 | 
 56 |     @GetMapping("/getLoginInfo")
 57 |     public String getLoginInfo(HttpServletRequest request) {
 58 |         HttpSession session = request.getSession();
 59 |         String id = (String) session.getAttribute("id");
 60 |         if (id == null)
 61 |             return Constant.FAILURE;
 62 |         return "{\"success\":\"true\",\"id\":\"" + id + "\"}";
 63 |     }
 64 | 
 65 |     @GetMapping("/delete/video/{id}")
 66 |     public String deleteVideo(@PathVariable("id") long id, HttpServletRequest request) {
 67 |         if (!isAdmin(request)) return Constant.NoPermission;
 68 |         Video video = redisTools.getFromHashAsObject("VideoStation:Video:" + id, Video.class);
 69 |         if (video == null) return Constant.FAILURE;
 70 |         redisTools.getRedisTemplate().delete("VideoStation:Video:" + id);
 71 |         videoMapper.deleteOne(String.valueOf(id));
 72 |         File videoImg = new File("/opt/Server/videoStation/videoImg/" + id);
 73 |         if (videoImg.exists()) videoImg.delete();
 74 |         File videoFile = new File("/opt/Server/videoStation/video/" + id);
 75 |         if (videoFile.exists()) {
 76 |             File[] files = videoFile.listFiles();
 77 |             if (files != null) {
 78 |                 for (File file : files) {
 79 |                     file.delete();
 80 |                 }
 81 |             }
 82 |             videoFile.delete();
 83 |         }
 84 |         return Constant.SUCCESS;
 85 |     }
 86 | 
 87 |     @GetMapping("/getAllAccount")
 88 |     public List<Account> getAll(HttpServletRequest request) {
 89 |         if (!isAdmin(request))
 90 |             return new ArrayList<>();
 91 |         return accountMapper.getAll();
 92 |     }
 93 | 
 94 |     @PostMapping("/update/{id}")
 95 |     public String ban(@PathVariable("id") long id,@RequestBody Map<String,String> body,  HttpServletRequest request) {
 96 |         String name = body.get("name");
 97 |         String banned = body.get("banned");
 98 |         String password = body.get("password");
 99 |         if (!isAdmin(request))
100 |             return Constant.NoPermission;
101 |         Account account = redisTools.selectAccountInCache(id);
102 |         if (account == null) return Constant.FAILURE;
103 |         if(banned!=null){
104 |             account.setBanned(Integer.parseInt(banned));
105 |             redisTools.getRedisTemplate().opsForHash().put("VideoStation:Account:" + account.getId(),"banned",banned);
106 |         }
107 |         if(name!=null){
108 |             account.setName(name);
109 |             redisTools.getRedisTemplate().opsForHash().put("VideoStation:Account:" + account.getId(),"name",name);
110 |         }
111 |         if(password!=null){
112 |             String newPwd = MD5Transfer.encode(password);
113 |             account.setPassword(newPwd);
114 |             redisTools.getRedisTemplate().opsForHash().put("VideoStation:Account:" + account.getId(),"password",newPwd);
115 |         }
116 |         accountMapper.updateOne(account);
117 |         return Constant.SUCCESS;
118 |     }
119 |     @PostMapping("/updateVideo/{id}")
120 |     public String updateVideo(@PathVariable("id")String id,@RequestBody Map<String,String> body,HttpServletRequest request){
121 |         String title = body.get("title");
122 |         String summary = body.get("summary");
123 |         if (!isAdmin(request))
124 |             return Constant.NoPermission;
125 |         Video video = redisTools.selectVideoInCache(id);
126 |         if (video==null) return Constant.FAILURE;
127 |         if(title!=null){
128 |             video.setTitle(title);
129 |             redisTools.getRedisTemplate().opsForHash().put("VideoStation:Video:"+id,"title",title);
130 |         }
131 |         if(summary!=null){
132 |             video.setTitle(title);
133 |             redisTools.getRedisTemplate().opsForHash().put("VideoStation:Video:"+id,"summary",summary);
134 |         }
135 |         return Constant.SUCCESS;
136 |     }
137 |     private boolean isAdmin(HttpServletRequest request) {
138 |         HttpSession session = request.getSession();
139 |         String id = (String) session.getAttribute("id");
140 |         if (id == null || !id.equals("10063301")) return false;
141 |         return true;
142 |     }
143 | }
144 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/tools/Constant.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.tools;
  2 | 
  3 | import com.fasterxml.jackson.databind.ObjectMapper;
  4 | import com.lingyi.RootGet.entry.Video;
  5 | 
  6 | import javax.servlet.http.Cookie;
  7 | import javax.servlet.http.HttpServletRequest;
  8 | import java.io.File;
  9 | import java.text.ParseException;
 10 | import java.text.SimpleDateFormat;
 11 | import java.util.ArrayList;
 12 | import java.util.Date;
 13 | import java.util.List;
 14 | import java.util.Random;
 15 | 
 16 | public class Constant {
 17 |     /***** 文件不存在*****/
 18 |     public static String FileNotExists = "{\"success\":\"false\",\"reason\":\"FileNotExists\"}";
 19 |     /***** 文件已存在*****/
 20 |     public static String FileExists = "{\"success\":\"false\",\"reason\":\"FileExists\"}";
 21 |     /***** 成功*****/
 22 |     public static String SUCCESS = "{\"success\":\"true\",\"reason\":\"null\"}";
 23 |     /***** 失败*****/
 24 |     public static String FAILURE = "{\"success\":\"false\",\"reason\":\"unknown\"}";
 25 |     /***** 没有权限*****/
 26 |     public static String NoPermission = "{\"success\":\"false\",\"reason\":\"NoPermission\"}";
 27 |     /***** 项目(商品)未找到*****/
 28 |     public static String ItemNotFound = "{\"success\":\"false\",\"reason\":\"ItemNotFound\"}";
 29 |     /***** 商品图片储存路劲*****/
 30 |     public static String RepositoryPath = "/opt/Server/DigitalStoreRepository/";
 31 |     /***** 账号不存在*****/
 32 |     public static String AccountNotExists = "{\"success\":\"false\",\"reason\":\"AccountNotFound\"}";
 33 |     /***** 密码不正确****/
 34 |     public static String PasswordIncorrect = "{\"success\":\"false\",\"reason\":\"PasswordIncorrect\"}";
 35 |     /***** 空json*****/
 36 |     public static String EmptyJson = "{}";
 37 |     /*****地址已存在*****/
 38 |     public static String AddressExists = "{\"success\":\"false\",\"reason\":\"AddressExists\"}";
 39 |     /*****物品已经被添加到购物车*****/
 40 |     public static String CartExists = "{\"success\":\"false\",\"reason\":\"CartExists\"}";
 41 |     /*****请求次数过多*****/
 42 |     public static String TooMuchTimes = "{\"success\":\"false\",\"reason\":\"TooMuchTimes\"}";
 43 |     /**包含违禁词*/
 44 |     public static String WordsForbidden = "{\"success\":\"false\",\"reason\":\"WordsForbidden\"}";
 45 |     public static String AccountBanned = "{\"success\":\"false\",\"reason\":\"AccountBanned\"}";
 46 |     public static String KeyExists = "{\"success\":\"false\",\"reason\":\"KeyExists\"}";
 47 |     public static ArrayList<String> forbiddenWords = new ArrayList<>();
 48 | 
 49 |     public static ArrayList<String> getForbiddenWords() {
 50 |         if (forbiddenWords.size() != 0)
 51 |             return forbiddenWords;
 52 |         else{
 53 |             forbiddenWords.add("共产党");
 54 |             forbiddenWords.add("傻逼");
 55 |             forbiddenWords.add("你妈逼");
 56 |             forbiddenWords.add("操你妈");
 57 |             forbiddenWords.add("日你妈");
 58 |             forbiddenWords.add("肏");
 59 |             forbiddenWords.add("屄");
 60 |         }
 61 |         return forbiddenWords;
 62 |     }
 63 |     /*****token生成器*****/
 64 |     /**
 65 |      * @param bounds 生成的token长度
 66 |      **/
 67 |     public static String tokenGenerate(int bounds) {
 68 |         String token = "";
 69 |         Random random = new Random();
 70 |         for (int j = 0; j < bounds; j++) {
 71 |             int i = random.nextInt(3);
 72 |             switch (i) {
 73 |                 case 0:
 74 |                     token += (char) (random.nextInt(26) + 65);
 75 |                     break;
 76 |                 case 1:
 77 |                     token += (char) (random.nextInt(26) + 97);
 78 |                     break;
 79 |                 case 2:
 80 |                     token += random.nextInt(10);
 81 |                     break;
 82 |             }
 83 |         }
 84 |         return token;
 85 |     }
 86 | 
 87 |     /*****从浏览器cookie中获取uid*****/
 88 |     public static String getUidInCookie(HttpServletRequest request) {
 89 |         String id = null;
 90 |         Cookie[] cookies = request.getCookies();
 91 |         if (cookies == null) return id;
 92 |         for (Cookie cookie : cookies) {
 93 |             if (cookie.getName().equalsIgnoreCase("uid")) {
 94 |                 id = cookie.getValue();
 95 |                 return id;
 96 |             }
 97 |         }
 98 |         return id;
 99 |     }
100 |     /*****从浏览器cookie中获取token*****/
101 |     public static String getTokenInCookie(HttpServletRequest request) {
102 |         String token = null;
103 |         Cookie[] cookies = request.getCookies();
104 |         if (cookies == null) return token;
105 |         for (Cookie cookie : cookies) {
106 |             if (cookie.getName().equalsIgnoreCase("token")) {
107 |                 token = cookie.getValue();
108 |                 return token;
109 |             }
110 |         }
111 |         return token;
112 |     }
113 | 
114 |     /*****String时间转换long*****/
115 |     public static long StringParseToLong(String time_string) {
116 |         Date date;
117 |         try {
118 |             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
119 |             date = sdf.parse(time_string);
120 |             return date.getTime();
121 |         } catch (ParseException e) {
122 |             throw new RuntimeException(e);
123 |         }
124 |     }
125 | 
126 |     /*****文件大小bit转换成KB MB GB等*****/
127 |     public static String transformToString(long fileSize) {
128 |         String StringSize = "";
129 |         if (fileSize < 1024) StringSize = fileSize + "B";
130 |         if (fileSize >= 1024 && fileSize < 1048576) {
131 |             double result = fileSize * 1.0 / 1024 * 1.0;
132 |             String result_str = String.valueOf(result);
133 |             String[] split = result_str.split("\\.");
134 |             if (split[1].length() > 2) StringSize = split[0] + "." + split[1].substring(0, 2) + "KB";
135 |             else StringSize = split[0] + "." + split[1] + "KB";
136 |         }
137 |         if (fileSize >= 1048576 && fileSize < 1073741824) {
138 |             double result = fileSize * 1.0 / 1048576 * 1.0;
139 |             String result_str = String.valueOf(result);
140 |             String[] split = result_str.split("\\.");
141 |             if (split[1].length() > 2) StringSize = split[0] + "." + split[1].substring(0, 2) + "MB";
142 |             else StringSize = split[0] + "." + split[1] + "MB";
143 |         }
144 |         if (fileSize >= 1073741824) {
145 |             double result = fileSize * 1.0 / 1073741824 * 1.0;
146 |             String result_str = String.valueOf(result);
147 |             String[] split = result_str.split("\\.");
148 |             if (split[1].length() > 2) StringSize = split[0] + "." + split[1].substring(0, 2) + "GB";
149 |             else StringSize = split[0] + "." + split[1] + "GB";
150 |         }
151 |         return StringSize;
152 |     }
153 | 
154 |     /*****获取文件后缀*****/
155 |     public static String getFileType(File file) {
156 |         String fileName = file.getName();
157 |         String[] strings = fileName.split("\\.");
158 |         String fileType = strings[strings.length - 1];
159 |         return fileType;
160 |     }
161 | }
162 | 


--------------------------------------------------------------------------------
/mvnw.cmd:
--------------------------------------------------------------------------------
  1 | @REM ----------------------------------------------------------------------------
  2 | @REM Licensed to the Apache Software Foundation (ASF) under one
  3 | @REM or more contributor license agreements.  See the NOTICE file
  4 | @REM distributed with this work for additional information
  5 | @REM regarding copyright ownership.  The ASF licenses this file
  6 | @REM to you under the Apache License, Version 2.0 (the
  7 | @REM "License"); you may not use this file except in compliance
  8 | @REM with the License.  You may obtain a copy of the License at
  9 | @REM
 10 | @REM    https://www.apache.org/licenses/LICENSE-2.0
 11 | @REM
 12 | @REM Unless required by applicable law or agreed to in writing,
 13 | @REM software distributed under the License is distributed on an
 14 | @REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 15 | @REM KIND, either express or implied.  See the License for the
 16 | @REM specific language governing permissions and limitations
 17 | @REM under the License.
 18 | @REM ----------------------------------------------------------------------------
 19 | 
 20 | @REM ----------------------------------------------------------------------------
 21 | @REM Maven Start Up Batch script
 22 | @REM
 23 | @REM Required ENV vars:
 24 | @REM JAVA_HOME - location of a JDK home dir
 25 | @REM
 26 | @REM Optional ENV vars
 27 | @REM M2_HOME - location of maven2's installed home dir
 28 | @REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
 29 | @REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
 30 | @REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
 31 | @REM     e.g. to debug Maven itself, use
 32 | @REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
 33 | @REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
 34 | @REM ----------------------------------------------------------------------------
 35 | 
 36 | @REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
 37 | @echo off
 38 | @REM set title of command window
 39 | title %0
 40 | @REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
 41 | @if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
 42 | 
 43 | @REM set %HOME% to equivalent of $HOME
 44 | if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
 45 | 
 46 | @REM Execute a user defined script before this one
 47 | if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
 48 | @REM check for pre script, once with legacy .bat ending and once with .cmd ending
 49 | if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
 50 | if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
 51 | :skipRcPre
 52 | 
 53 | @setlocal
 54 | 
 55 | set ERROR_CODE=0
 56 | 
 57 | @REM To isolate internal variables from possible post scripts, we use another setlocal
 58 | @setlocal
 59 | 
 60 | @REM ==== START VALIDATION ====
 61 | if not "%JAVA_HOME%" == "" goto OkJHome
 62 | 
 63 | echo.
 64 | echo Error: JAVA_HOME not found in your environment. >&2
 65 | echo Please set the JAVA_HOME variable in your environment to match the >&2
 66 | echo location of your Java installation. >&2
 67 | echo.
 68 | goto error
 69 | 
 70 | :OkJHome
 71 | if exist "%JAVA_HOME%\bin\java.exe" goto init
 72 | 
 73 | echo.
 74 | echo Error: JAVA_HOME is set to an invalid directory. >&2
 75 | echo JAVA_HOME = "%JAVA_HOME%" >&2
 76 | echo Please set the JAVA_HOME variable in your environment to match the >&2
 77 | echo location of your Java installation. >&2
 78 | echo.
 79 | goto error
 80 | 
 81 | @REM ==== END VALIDATION ====
 82 | 
 83 | :init
 84 | 
 85 | @REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
 86 | @REM Fallback to current working directory if not found.
 87 | 
 88 | set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
 89 | IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
 90 | 
 91 | set EXEC_DIR=%CD%
 92 | set WDIR=%EXEC_DIR%
 93 | :findBaseDir
 94 | IF EXIST "%WDIR%"\.mvn goto baseDirFound
 95 | cd ..
 96 | IF "%WDIR%"=="%CD%" goto baseDirNotFound
 97 | set WDIR=%CD%
 98 | goto findBaseDir
 99 | 
100 | :baseDirFound
101 | set MAVEN_PROJECTBASEDIR=%WDIR%
102 | cd "%EXEC_DIR%"
103 | goto endDetectBaseDir
104 | 
105 | :baseDirNotFound
106 | set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
107 | cd "%EXEC_DIR%"
108 | 
109 | :endDetectBaseDir
110 | 
111 | IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
112 | 
113 | @setlocal EnableExtensions EnableDelayedExpansion
114 | for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
115 | @endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
116 | 
117 | :endReadAdditionalConfig
118 | 
119 | SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
120 | set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
121 | set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
122 | 
123 | set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
124 | 
125 | FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
126 |     IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
127 | )
128 | 
129 | @REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
130 | @REM This allows using the maven wrapper in projects that prohibit checking in binary data.
131 | if exist %WRAPPER_JAR% (
132 |     if "%MVNW_VERBOSE%" == "true" (
133 |         echo Found %WRAPPER_JAR%
134 |     )
135 | ) else (
136 |     if not "%MVNW_REPOURL%" == "" (
137 |         SET DOWNLOAD_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
138 |     )
139 |     if "%MVNW_VERBOSE%" == "true" (
140 |         echo Couldn't find %WRAPPER_JAR%, downloading it ...
141 |         echo Downloading from: %DOWNLOAD_URL%
142 |     )
143 | 
144 |     powershell -Command "&{"^
145 | 		"$webclient = new-object System.Net.WebClient;"^
146 | 		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
147 | 		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
148 | 		"}"^
149 | 		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^
150 | 		"}"
151 |     if "%MVNW_VERBOSE%" == "true" (
152 |         echo Finished downloading %WRAPPER_JAR%
153 |     )
154 | )
155 | @REM End of extension
156 | 
157 | @REM Provide a "standardized" way to retrieve the CLI args that will
158 | @REM work with both Windows and non-Windows executions.
159 | set MAVEN_CMD_LINE_ARGS=%*
160 | 
161 | %MAVEN_JAVA_EXE% ^
162 |   %JVM_CONFIG_MAVEN_PROPS% ^
163 |   %MAVEN_OPTS% ^
164 |   %MAVEN_DEBUG_OPTS% ^
165 |   -classpath %WRAPPER_JAR% ^
166 |   "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
167 |   %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
168 | if ERRORLEVEL 1 goto error
169 | goto end
170 | 
171 | :error
172 | set ERROR_CODE=1
173 | 
174 | :end
175 | @endlocal & set ERROR_CODE=%ERROR_CODE%
176 | 
177 | if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
178 | @REM check for post script, once with legacy .bat ending and once with .cmd ending
179 | if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
180 | if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
181 | :skipRcPost
182 | 
183 | @REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
184 | if "%MAVEN_BATCH_PAUSE%"=="on" pause
185 | 
186 | if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
187 | 
188 | cmd /C exit /B %ERROR_CODE%
189 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/AccountController.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.controller;
  2 | 
  3 | import com.lingyi.RootGet.entry.Account;
  4 | import com.lingyi.RootGet.entry.Video;
  5 | import com.lingyi.RootGet.mapper.video.AccountMapper;
  6 | import com.lingyi.RootGet.mapper.video.CommentMapper;
  7 | import com.lingyi.RootGet.mapper.video.VideoMapper;
  8 | import com.lingyi.RootGet.tools.Constant;
  9 | import com.lingyi.RootGet.tools.MD5Transfer;
 10 | import com.lingyi.RootGet.tools.RedisTools;
 11 | import org.springframework.util.StringUtils;
 12 | import org.springframework.web.bind.annotation.*;
 13 | import org.springframework.web.multipart.MultipartFile;
 14 | 
 15 | import javax.servlet.ServletOutputStream;
 16 | import javax.servlet.http.Cookie;
 17 | import javax.servlet.http.HttpServletRequest;
 18 | import javax.servlet.http.HttpServletResponse;
 19 | import java.io.*;
 20 | import java.util.ArrayList;
 21 | import java.util.List;
 22 | import java.util.Map;
 23 | import java.util.concurrent.TimeUnit;
 24 | 
 25 | @RestController
 26 | @RequestMapping("/api/account")
 27 | public class AccountController {
 28 |     private final RedisTools redisTools;
 29 |     private final AccountMapper accountMapper;
 30 |     private final VideoMapper videoMapper;
 31 |     private final CommentMapper commentMapper;
 32 | 
 33 |     public AccountController(RedisTools redisTools, AccountMapper accountMapper, VideoMapper videoMapper,CommentMapper commentMapper) {
 34 |         this.redisTools = redisTools;
 35 |         this.accountMapper = accountMapper;
 36 |         this.videoMapper = videoMapper;
 37 |         this.commentMapper = commentMapper;
 38 |     }
 39 | 
 40 |     @PostMapping(value = "/login")
 41 |     public String login(@RequestBody Map<String, String> body, HttpServletResponse response) {
 42 |         //是否输入账号密码
 43 |         String id = body.get("id");
 44 |         String pwd = body.get("password");
 45 |         if (!StringUtils.hasText(id) || !StringUtils.hasText(pwd)) {
 46 |             //response.setStatus(401);
 47 |             return Constant.FAILURE;
 48 |         }
 49 |         try {
 50 |             Long.parseLong(id);
 51 |         } catch (Exception e) {
 52 |             return Constant.FAILURE;
 53 |         }
 54 |         Account account = redisTools.selectAccountInCache(Long.parseLong(id));
 55 |         //账号被封禁
 56 |         if(account !=null && account.getBanned() == 1)
 57 |             return Constant.AccountBanned;
 58 |         //验证账号密码
 59 |         if (account != null && MD5Transfer.encode(pwd).equals(account.getPassword())) {
 60 |             //添加cookie
 61 |             Cookie cookie_uid = new Cookie("uid", id);
 62 |             cookie_uid.setPath("/");
 63 |             cookie_uid.setMaxAge(3600 * 24 * 7);
 64 |             String token = redisTools.setAccountToken(account.getId(), 7, TimeUnit.DAYS);
 65 |             Cookie cookie_token = new Cookie("token", token);
 66 |             cookie_token.setPath("/");
 67 |             cookie_token.setMaxAge(3600 * 24 * 7);
 68 |             response.addCookie(cookie_uid);
 69 |             response.addCookie(cookie_token);
 70 |         } else return Constant.FAILURE;
 71 |         return Constant.SUCCESS;
 72 |     }
 73 | 
 74 |     @PostMapping("/register")
 75 |     public String register(@RequestBody Map<String, String> body, HttpServletRequest request) {
 76 |         String id_session = request.getSession().getId();
 77 |         boolean lock = redisTools.setLock(id_session, "Register");
 78 | 
 79 |         if (!lock) {
 80 |             long ttl = redisTools.getLockTTL(id_session, "Register");
 81 |             return "{\"success\":\"failure\",\"reason\":\"TooMuchTimes\",\"wait\":\"" + ttl + "\"}";
 82 |         }
 83 |         String name = body.get("name");
 84 |         String password = body.get("password");
 85 |         Account account = new Account();
 86 |         account.setName(name).setPassword(MD5Transfer.encode(password));
 87 |         accountMapper.addOne(account);
 88 | 
 89 |         return "{\"id\":\"" + account.getId() + "\",\"name\":\"" + account.getName() + "\",\"password\":\"******\"}";
 90 |     }
 91 | 
 92 |     @GetMapping("/selectOneById/{id}")
 93 |     public Account selectOne(@PathVariable("id") long id) {
 94 |         return redisTools.selectAccountInCache(id).setPassword("******");
 95 |     }
 96 | 
 97 |     @GetMapping("/userSearch")
 98 |     public List<Account> search(@RequestParam("keywords") String keywords) {
 99 |         if (!StringUtils.hasText(keywords)) return new ArrayList<>();
100 |         List<Account> accounts = accountMapper.selectByKeywords(keywords);
101 |         for (Account account : accounts) {
102 |             account.setPassword("******");
103 |         }
104 |         return accounts;
105 |     }
106 | 
107 |     @GetMapping("/getLoginInfo")
108 |     public String getLoginInfo(HttpServletRequest request) {
109 |         String uid = Constant.getUidInCookie(request);
110 |         String token = Constant.getTokenInCookie(request);
111 |         if (uid == null || token == null) return Constant.FAILURE;
112 |         String accountToken = redisTools.getAccountToken(Long.parseLong(uid));
113 |         if (!token.equals(accountToken)) return Constant.FAILURE;
114 |         return "{\"success\":\"true\",\"uid\":\"" + uid + "\"}";
115 |     }
116 | 
117 |     @PostMapping("/upLoadProfile/{uid}")
118 |     public String upload(@PathVariable("uid") String uid, @RequestParam("file") MultipartFile multipartFile) {
119 |         File root = new File("此处放头像" + uid);
120 |         if (!root.exists()) root.mkdirs();
121 |         File profile = new File(root.getAbsolutePath() + "/profile.file");
122 |         if (profile.exists())
123 |             profile.delete();
124 |         try {
125 |             multipartFile.transferTo(profile);
126 |         } catch (IOException e) {
127 |             throw new RuntimeException(e);
128 |             //return Constant.FAILURE;
129 |         }
130 |         return Constant.SUCCESS;
131 |     }
132 | 
133 |     @GetMapping("/getProfile/{uid}")
134 |     public void profile(@PathVariable("uid") String uid, HttpServletResponse response) {
135 |         File profile = new File("头像文件夹" + uid + "/profile.file");
136 |         if (!profile.exists()) {
137 |             response.setStatus(404);
138 |             return;
139 |         }
140 |         response.setContentType("image/png");
141 |         ServletOutputStream outputStream;
142 |         BufferedInputStream bis = null;
143 |         try {
144 |             outputStream = response.getOutputStream();
145 |             bis = new BufferedInputStream(new FileInputStream(profile));
146 |             int len;
147 |             byte[] bytes = new byte[2048];
148 |             while ((len = bis.read(bytes)) != -1) {
149 |                 outputStream.write(bytes, 0, len);
150 |             }
151 |             bis.close();
152 |         } catch (IOException e) {
153 |             throw new RuntimeException(e);
154 |         }finally {
155 |             try {
156 |                 bis.close();
157 |             } catch (IOException e) {
158 |                 throw new RuntimeException(e);
159 |             }
160 |         }
161 |     }
162 | 
163 |     @GetMapping("/logout/{uid}")
164 |     public void logout(@PathVariable("uid") long uid) {
165 |         redisTools.getRedisTemplate().delete("VideoStation:Token:" + uid);
166 |     }
167 | 
168 |     @PostMapping("/change")
169 |     public String changeName(@RequestBody Map<String, String> body, HttpServletRequest request) {
170 |         //获取参数
171 |         String uid = body.get("uid");
172 |         long uid_long = Long.parseLong(uid);
173 |         //权限认证
174 |         if (!isLogin(uid_long, request))
175 |             return Constant.NoPermission;
176 |         //获取账号
177 |         Account account = redisTools.selectAccountInCache(uid_long);
178 |         if (account == null) return Constant.AccountNotExists;
179 |         String newName = body.get("newName");
180 |         String newPassword = body.get("newPassword");
181 |         String password = body.get(("password"));
182 |         if (StringUtils.hasText(newName))
183 |             account.setName(newName);
184 |         if (StringUtils.hasText(newPassword)&&StringUtils.hasText(password)){
185 |             if(!MD5Transfer.encode(password).equals(account.getPassword()))
186 |                 return Constant.PasswordIncorrect;
187 |             account.setPassword(MD5Transfer.encode(newPassword));
188 |         }
189 |         //更改数据
190 |         accountMapper.updateOne(account);
191 |         redisTools.getRedisTemplate().opsForHash().put("VideoStation:Account:" + uid, "name", account.getName());
192 |         redisTools.getRedisTemplate().opsForHash().put("VideoStation:Account:" + uid, "password", account.getPassword());
193 | 
194 |         List<Video> list = videoMapper.selectByUp(uid_long);
195 |         if(list!=null&&!list.isEmpty()){
196 |             commentMapper.updateName(list.get(0).getUpName(),newName);
197 |             videoMapper.updateUpName(list.get(0).getUpName(),newName);
198 |             for (Video video : list) {
199 |                 video.setUpName(newName);
200 |                 redisTools.getRedisTemplate().opsForHash().put("VideoStation:Video:" + video.getId(), "upName", newName);
201 |             }
202 |         }
203 | 
204 |         return Constant.SUCCESS;
205 |     }
206 | 
207 |     private boolean isLogin(long id, HttpServletRequest request) {
208 |         String uid = Constant.getUidInCookie(request);
209 |         String token = Constant.getTokenInCookie(request);
210 |         if (!StringUtils.hasText(uid) || !StringUtils.hasText(token))
211 |             return false;
212 |         long uid_long = Long.parseLong(uid);
213 |         if (uid_long != id)
214 |             return false;
215 |         String accountToken = redisTools.getAccountToken(id);
216 |         if (!token.equals(accountToken))
217 |             return false;
218 |         return true;
219 |     }
220 | }
221 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/controller/VideoController.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.controller;
  2 | 
  3 | import com.lingyi.RootGet.entry.Account;
  4 | import com.lingyi.RootGet.entry.Video;
  5 | import com.lingyi.RootGet.mapper.video.VideoMapper;
  6 | import com.lingyi.RootGet.tools.Constant;
  7 | import com.lingyi.RootGet.tools.RedisTools;
  8 | import com.lingyi.RootGet.tools.SnowFlake;
  9 | import eu.bitwalker.useragentutils.Browser;
 10 | import eu.bitwalker.useragentutils.BrowserType;
 11 | import eu.bitwalker.useragentutils.UserAgent;
 12 | import org.springframework.beans.factory.annotation.Autowired;
 13 | import org.springframework.data.redis.core.StringRedisTemplate;
 14 | import org.springframework.util.StringUtils;
 15 | import org.springframework.web.bind.annotation.*;
 16 | import org.springframework.web.multipart.MultipartFile;
 17 | 
 18 | import javax.servlet.http.HttpServletRequest;
 19 | import javax.servlet.http.HttpServletResponse;
 20 | import java.io.BufferedInputStream;
 21 | import java.io.File;
 22 | import java.io.FileInputStream;
 23 | import java.io.IOException;
 24 | import java.util.*;
 25 | 
 26 | @RestController
 27 | @RequestMapping("/api")
 28 | public class VideoController {
 29 |     private final RedisTools redisTools;
 30 |     private final VideoMapper videoMapper;
 31 | 
 32 |     @Autowired
 33 |     private VideoController(RedisTools redisTools, VideoMapper videoMapper) {
 34 |         this.redisTools = redisTools;
 35 |         this.videoMapper = videoMapper;
 36 |     }
 37 |     //获取视频列表
 38 |     @GetMapping("/video/videoList/{id}")
 39 |     public List<String> getVideoList(@PathVariable("id") String id) {
 40 |         StringRedisTemplate redisTemplate = redisTools.getRedisTemplate();
 41 |         Boolean hasKey = redisTemplate.hasKey("VideoStation:Video:" + id);
 42 |         if (!hasKey) return null;
 43 |         File root = new File("视频保存文件夹" + id);
 44 |         File[] files = root.listFiles();
 45 |         if (files == null || files.length == 0) return null;
 46 |         List<String> fileList = new ArrayList<>();
 47 |         for (File file : files) {
 48 |             fileList.add(file.getName());
 49 |         }
 50 |         return fileList;
 51 |     }
 52 |     //获取视频文件
 53 |     @GetMapping("/video/{id}/{filename}")
 54 |     public String getVideo(@PathVariable("id") long id, @PathVariable("filename") String filename, HttpServletRequest request, HttpServletResponse response) {
 55 |         String origin = request.getHeader("Sec-Fetch-Site");
 56 |         String userAgent = request.getHeader("User-Agent");
 57 |         UserAgent ua = UserAgent.parseUserAgentString(userAgent);
 58 |         Browser browser = ua.getBrowser().getGroup();
 59 |         String bwt = browser.toString();
 60 |         if(origin!=null){
 61 |             if (!origin.equals("same-origin")) {
 62 |                 response.setStatus(403);
 63 |                 return null;
 64 |             }
 65 |         }
 66 |         //文件位置
 67 |         File file = new File("视频保存文件夹" + id + "/" + filename);
 68 |         if (!file.exists()) {
 69 |             return Constant.FileNotExists;
 70 |         }
 71 |         //初始化开始和结束
 72 |         long start = 0;
 73 |         long end = file.length() - 1;
 74 |         //从HttpRequestHeader中获取Range(文件断点开始处)
 75 |         String range = request.getHeader("Range");
 76 |         //若没有断点，则直接完整下载
 77 |         if (range != null) {
 78 |             //存在断点，重新设置开始和结束
 79 |             String[] strings = range.split("=");
 80 |             String[] split = strings[1].split("-");
 81 |             start = Long.parseLong(split[0]);
 82 |             if (split.length > 1) end = Long.parseLong(split[1]);
 83 |         }
 84 |         response.setContentType("video/" + Constant.getFileType(file));
 85 |         if (start == 0) {
 86 |             //response.setContentLengthLong(file.length());
 87 |             response.setStatus(200);
 88 |         } else {
 89 |             response.setStatus(206);
 90 |         }
 91 |         response.setContentLengthLong(end - start + 1);
 92 |         response.setHeader("Accept-Ranges", "bytes");
 93 |         response.setHeader("Content-Range", "bytes " + start + "-" + end + "/" + file.length());
 94 |         BufferedInputStream bis = null;
 95 |         try {
 96 |             bis = new BufferedInputStream(new FileInputStream(file));
 97 |             //跳过的文件长度等于断点位置，可将BufferedInputStream更换为RandomAccessFile
 98 |             bis.skip(start);
 99 |             byte[] bytes = new byte[2048];
100 |             int len;
101 |             while ((len = bis.read(bytes)) != -1) {
102 |                 response.getOutputStream().write(bytes, 0, len);
103 |             }
104 |         } catch (IOException e) {
105 |             return "{\"success\":\"false\"}";
106 |             //e.printStackTrace();
107 |         }finally {
108 |             try {
109 |                 bis.close();
110 |             } catch (IOException e) {
111 |                 throw new RuntimeException(e);
112 |             }
113 |         }
114 |         return Constant.SUCCESS;
115 |     }
116 |     //获取视频信息
117 |     @GetMapping("/video/information/{id}")
118 |     public Video getInformation(@PathVariable("id") String id) {
119 |         return redisTools.selectVideoInCache(id);
120 |     }
121 |     //获取首页获取视频
122 |     @GetMapping("/video/getVideos/{count}")
123 |     public Set<Video> getVideos(@PathVariable("count") int count, @RequestParam("first") boolean isFirst, HttpServletRequest request) {
124 |         return redisTools.getVideos(count, request.getSession(), isFirst);
125 |     }
126 |     //搜索
127 |     @GetMapping("/video/search")
128 |     public List<Video> search(@RequestParam("keywords") String keywords) {
129 |         List<Video> list = new ArrayList<>();
130 |         if (!StringUtils.hasText(keywords)) return list;
131 |         Set<String> keys = redisTools.getKeys("VideoStation:Video:*");
132 |         for (String key : keys) {
133 |             Video video = redisTools.getFromHashAsObject(key, Video.class);
134 |             if (video.getTitle().toLowerCase().contains(keywords.toLowerCase()))
135 |                 list.add(video);
136 |         }
137 |         return rankByPlay(list);
138 |     }
139 |     //点赞
140 |     @GetMapping("/video/addLike/{id}")
141 |     public long addLike(@PathVariable("id") String id) {
142 |         if (!redisTools.getRedisTemplate().hasKey("VideoStation:Video:" + id)) return -1;
143 |         return redisTools.videoAddALike(id);
144 |     }
145 |     //取消点赞
146 |     @GetMapping("/video/disLike/{id}")
147 |     public long disLike(@PathVariable("id") String id) {
148 |         if (!redisTools.getRedisTemplate().hasKey("VideoStation:Video:" + id)) return -1;
149 |         return redisTools.videoAddADisLike(id);
150 |     }
151 |     //查询用户上传
152 |     @GetMapping("/video/getByUp/{uid}")
153 |     public List<Video> getByUp(@PathVariable("uid") long uid) {
154 |         return videoMapper.selectByUp(uid);
155 |     }
156 |     //上传视频
157 |     @PostMapping("/video/addVideo")
158 |     public String addNew(@RequestBody Map<String, String> body) {
159 |         String title = body.get("title");
160 |         String summary = body.get("summary");
161 |         String up = body.get("up");
162 |         Account account = redisTools.selectAccountInCache(Long.parseLong(up));
163 |         ArrayList<String> forbiddenWords = Constant.getForbiddenWords();
164 |         if (forbiddenWords.contains(title) || forbiddenWords.contains(summary)) return Constant.WordsForbidden;
165 |         SnowFlake snowFlake = new SnowFlake(1);
166 |         long id = snowFlake.nextId();
167 |         Video video = new Video();
168 |         video.setId(String.valueOf(id));
169 |         video.setTitle(title);
170 |         video.setUp(Long.parseLong(up));
171 |         video.setSummary(summary);
172 |         video.setUpName(account.getName());
173 |         videoMapper.addOne(video);
174 |         video = videoMapper.selectOneById(String.valueOf(id));
175 |         redisTools.setAsHash("VideoStation:Video:" + id, video, -1, null);
176 |         return "{\"success\":\"true\",\"id\":\"" + video.getId() + "\"}";
177 |     }
178 | 
179 |     @PostMapping("/video/uploadVideoImg/{id}")
180 |     public String uploadVideoImg(@PathVariable("id") long id, @RequestPart("videoImg") MultipartFile multipartFile) {
181 |         File videoImg = new File("视频封面文件夹" + id);
182 |         if (!videoImg.getParentFile().exists()) videoImg.getParentFile().mkdirs();
183 |         if (videoImg.exists()) videoImg.delete();
184 |         try {
185 |             multipartFile.transferTo(videoImg);
186 |             return Constant.SUCCESS;
187 |         } catch (IOException e) {
188 |             throw new RuntimeException(e);
189 |         }
190 |     }
191 |     //上传视频文件保存
192 |     @PostMapping("/video/uploadVideo/{id}")
193 |     public String uploadVideo(@PathVariable("id") long id, @RequestPart("video") MultipartFile multipartFile) {
194 |         File videoFile = new File("视频封面文件夹" + id + "/" + multipartFile.getOriginalFilename());
195 |         if (!videoFile.getParentFile().exists()) videoFile.getParentFile().mkdirs();
196 |         if (videoFile.exists()) videoFile.delete();
197 |         try {
198 |             multipartFile.transferTo(videoFile);
199 |             return Constant.SUCCESS;
200 |         } catch (IOException e) {
201 |             throw new RuntimeException(e);
202 |         }
203 |     }
204 |     //删除视频
205 |     @PostMapping("/video/delete")
206 |     public String delete(@RequestBody Map<String, String> body) {
207 |         String id = body.get("id");
208 |         String uid = body.get("uid");
209 | 
210 |         Video video = redisTools.getFromHashAsObject("VideoStation:Video:" + id, Video.class);
211 |         if (video == null) return Constant.FAILURE;
212 |         if (video.getUp() != Long.parseLong(uid)) return Constant.NoPermission;
213 |         redisTools.getRedisTemplate().delete("VideoStation:Video:" + id);
214 |         videoMapper.deleteOne(id);
215 |         File videoImg = new File("视频封面文件夹" + id);
216 |         if (videoImg.exists()) videoImg.delete();
217 |         File videoFile = new File("视频文件夹" + id);
218 |         if (videoFile.exists()) {
219 |             File[] files = videoFile.listFiles();
220 |             if (files != null) {
221 |                 for (File file : files) {
222 |                     file.delete();
223 |                 }
224 |             }
225 |             videoFile.delete();
226 |         }
227 |         return Constant.SUCCESS;
228 |     }
229 |     //排序
230 |     private List<Video> rankByPlay(List<Video> arr) {
231 |         if (arr != null && arr.size() > 1) {
232 |             for (int i = 0; i < arr.size() - 1; i++) {
233 |                 // 初始化一个布尔值
234 |                 boolean flag = true;
235 |                 for (int j = 0; j < arr.size() - i - 1; j++) {
236 |                     if (arr.get(j).getPlay() > arr.get(j + 1).getPlay()) {
237 |                         // 调换
238 |                         Video temp;
239 |                         temp = arr.get(j);
240 |                         arr.set(j, arr.get(j + 1));
241 |                         arr.set(j + 1, temp);
242 |                         // 改变flag
243 |                         flag = false;
244 |                     }
245 |                 }
246 |                 if (flag) {
247 |                     break;
248 |                 }
249 |             }
250 |             Collections.reverse(arr);
251 |         }
252 |         System.out.println(arr);
253 |         return arr;
254 |     }
255 | }
256 | 


--------------------------------------------------------------------------------
/mvnw:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | # ----------------------------------------------------------------------------
  3 | # Licensed to the Apache Software Foundation (ASF) under one
  4 | # or more contributor license agreements.  See the NOTICE file
  5 | # distributed with this work for additional information
  6 | # regarding copyright ownership.  The ASF licenses this file
  7 | # to you under the Apache License, Version 2.0 (the
  8 | # "License"); you may not use this file except in compliance
  9 | # with the License.  You may obtain a copy of the License at
 10 | #
 11 | #    https://www.apache.org/licenses/LICENSE-2.0
 12 | #
 13 | # Unless required by applicable law or agreed to in writing,
 14 | # software distributed under the License is distributed on an
 15 | # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 16 | # KIND, either express or implied.  See the License for the
 17 | # specific language governing permissions and limitations
 18 | # under the License.
 19 | # ----------------------------------------------------------------------------
 20 | 
 21 | # ----------------------------------------------------------------------------
 22 | # Maven Start Up Batch script
 23 | #
 24 | # Required ENV vars:
 25 | # ------------------
 26 | #   JAVA_HOME - location of a JDK home dir
 27 | #
 28 | # Optional ENV vars
 29 | # -----------------
 30 | #   M2_HOME - location of maven2's installed home dir
 31 | #   MAVEN_OPTS - parameters passed to the Java VM when running Maven
 32 | #     e.g. to debug Maven itself, use
 33 | #       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
 34 | #   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
 35 | # ----------------------------------------------------------------------------
 36 | 
 37 | if [ -z "$MAVEN_SKIP_RC" ] ; then
 38 | 
 39 |   if [ -f /usr/local/etc/mavenrc ] ; then
 40 |     . /usr/local/etc/mavenrc
 41 |   fi
 42 | 
 43 |   if [ -f /etc/mavenrc ] ; then
 44 |     . /etc/mavenrc
 45 |   fi
 46 | 
 47 |   if [ -f "$HOME/.mavenrc" ] ; then
 48 |     . "$HOME/.mavenrc"
 49 |   fi
 50 | 
 51 | fi
 52 | 
 53 | # OS specific support.  $var _must_ be set to either true or false.
 54 | cygwin=false;
 55 | darwin=false;
 56 | mingw=false
 57 | case "`uname`" in
 58 |   CYGWIN*) cygwin=true ;;
 59 |   MINGW*) mingw=true;;
 60 |   Darwin*) darwin=true
 61 |     # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
 62 |     # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
 63 |     if [ -z "$JAVA_HOME" ]; then
 64 |       if [ -x "/usr/libexec/java_home" ]; then
 65 |         export JAVA_HOME="`/usr/libexec/java_home`"
 66 |       else
 67 |         export JAVA_HOME="/Library/Java/Home"
 68 |       fi
 69 |     fi
 70 |     ;;
 71 | esac
 72 | 
 73 | if [ -z "$JAVA_HOME" ] ; then
 74 |   if [ -r /etc/gentoo-release ] ; then
 75 |     JAVA_HOME=`java-config --jre-home`
 76 |   fi
 77 | fi
 78 | 
 79 | if [ -z "$M2_HOME" ] ; then
 80 |   ## resolve links - $0 may be a link to maven's home
 81 |   PRG="$0"
 82 | 
 83 |   # need this for relative symlinks
 84 |   while [ -h "$PRG" ] ; do
 85 |     ls=`ls -ld "$PRG"`
 86 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 87 |     if expr "$link" : '/.*' > /dev/null; then
 88 |       PRG="$link"
 89 |     else
 90 |       PRG="`dirname "$PRG"`/$link"
 91 |     fi
 92 |   done
 93 | 
 94 |   saveddir=`pwd`
 95 | 
 96 |   M2_HOME=`dirname "$PRG"`/..
 97 | 
 98 |   # make it fully qualified
 99 |   M2_HOME=`cd "$M2_HOME" && pwd`
100 | 
101 |   cd "$saveddir"
102 |   # echo Using m2 at $M2_HOME
103 | fi
104 | 
105 | # For Cygwin, ensure paths are in UNIX format before anything is touched
106 | if $cygwin ; then
107 |   [ -n "$M2_HOME" ] &&
108 |     M2_HOME=`cygpath --unix "$M2_HOME"`
109 |   [ -n "$JAVA_HOME" ] &&
110 |     JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
111 |   [ -n "$CLASSPATH" ] &&
112 |     CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
113 | fi
114 | 
115 | # For Mingw, ensure paths are in UNIX format before anything is touched
116 | if $mingw ; then
117 |   [ -n "$M2_HOME" ] &&
118 |     M2_HOME="`(cd "$M2_HOME"; pwd)`"
119 |   [ -n "$JAVA_HOME" ] &&
120 |     JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
121 | fi
122 | 
123 | if [ -z "$JAVA_HOME" ]; then
124 |   javaExecutable="`which javac`"
125 |   if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
126 |     # readlink(1) is not available as standard on Solaris 10.
127 |     readLink=`which readlink`
128 |     if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
129 |       if $darwin ; then
130 |         javaHome="`dirname \"$javaExecutable\"`"
131 |         javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
132 |       else
133 |         javaExecutable="`readlink -f \"$javaExecutable\"`"
134 |       fi
135 |       javaHome="`dirname \"$javaExecutable\"`"
136 |       javaHome=`expr "$javaHome" : '\(.*\)/bin'`
137 |       JAVA_HOME="$javaHome"
138 |       export JAVA_HOME
139 |     fi
140 |   fi
141 | fi
142 | 
143 | if [ -z "$JAVACMD" ] ; then
144 |   if [ -n "$JAVA_HOME"  ] ; then
145 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
146 |       # IBM's JDK on AIX uses strange locations for the executables
147 |       JAVACMD="$JAVA_HOME/jre/sh/java"
148 |     else
149 |       JAVACMD="$JAVA_HOME/bin/java"
150 |     fi
151 |   else
152 |     JAVACMD="`\\unset -f command; \\command -v java`"
153 |   fi
154 | fi
155 | 
156 | if [ ! -x "$JAVACMD" ] ; then
157 |   echo "Error: JAVA_HOME is not defined correctly." >&2
158 |   echo "  We cannot execute $JAVACMD" >&2
159 |   exit 1
160 | fi
161 | 
162 | if [ -z "$JAVA_HOME" ] ; then
163 |   echo "Warning: JAVA_HOME environment variable is not set."
164 | fi
165 | 
166 | CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
167 | 
168 | # traverses directory structure from process work directory to filesystem root
169 | # first directory with .mvn subdirectory is considered project base directory
170 | find_maven_basedir() {
171 | 
172 |   if [ -z "$1" ]
173 |   then
174 |     echo "Path not specified to find_maven_basedir"
175 |     return 1
176 |   fi
177 | 
178 |   basedir="$1"
179 |   wdir="$1"
180 |   while [ "$wdir" != '/' ] ; do
181 |     if [ -d "$wdir"/.mvn ] ; then
182 |       basedir=$wdir
183 |       break
184 |     fi
185 |     # workaround for JBEAP-8937 (on Solaris 10/Sparc)
186 |     if [ -d "${wdir}" ]; then
187 |       wdir=`cd "$wdir/.."; pwd`
188 |     fi
189 |     # end of workaround
190 |   done
191 |   echo "${basedir}"
192 | }
193 | 
194 | # concatenates all lines of a file
195 | concat_lines() {
196 |   if [ -f "$1" ]; then
197 |     echo "$(tr -s '\n' ' ' < "$1")"
198 |   fi
199 | }
200 | 
201 | BASE_DIR=`find_maven_basedir "$(pwd)"`
202 | if [ -z "$BASE_DIR" ]; then
203 |   exit 1;
204 | fi
205 | 
206 | ##########################################################################################
207 | # Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
208 | # This allows using the maven wrapper in projects that prohibit checking in binary data.
209 | ##########################################################################################
210 | if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
211 |     if [ "$MVNW_VERBOSE" = true ]; then
212 |       echo "Found .mvn/wrapper/maven-wrapper.jar"
213 |     fi
214 | else
215 |     if [ "$MVNW_VERBOSE" = true ]; then
216 |       echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
217 |     fi
218 |     if [ -n "$MVNW_REPOURL" ]; then
219 |       jarUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
220 |     else
221 |       jarUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
222 |     fi
223 |     while IFS="=" read key value; do
224 |       case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
225 |       esac
226 |     done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
227 |     if [ "$MVNW_VERBOSE" = true ]; then
228 |       echo "Downloading from: $jarUrl"
229 |     fi
230 |     wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
231 |     if $cygwin; then
232 |       wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
233 |     fi
234 | 
235 |     if command -v wget > /dev/null; then
236 |         if [ "$MVNW_VERBOSE" = true ]; then
237 |           echo "Found wget ... using wget"
238 |         fi
239 |         if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
240 |             wget "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
241 |         else
242 |             wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
243 |         fi
244 |     elif command -v curl > /dev/null; then
245 |         if [ "$MVNW_VERBOSE" = true ]; then
246 |           echo "Found curl ... using curl"
247 |         fi
248 |         if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
249 |             curl -o "$wrapperJarPath" "$jarUrl" -f
250 |         else
251 |             curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
252 |         fi
253 | 
254 |     else
255 |         if [ "$MVNW_VERBOSE" = true ]; then
256 |           echo "Falling back to using Java to download"
257 |         fi
258 |         javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
259 |         # For Cygwin, switch paths to Windows format before running javac
260 |         if $cygwin; then
261 |           javaClass=`cygpath --path --windows "$javaClass"`
262 |         fi
263 |         if [ -e "$javaClass" ]; then
264 |             if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
265 |                 if [ "$MVNW_VERBOSE" = true ]; then
266 |                   echo " - Compiling MavenWrapperDownloader.java ..."
267 |                 fi
268 |                 # Compiling the Java class
269 |                 ("$JAVA_HOME/bin/javac" "$javaClass")
270 |             fi
271 |             if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
272 |                 # Running the downloader
273 |                 if [ "$MVNW_VERBOSE" = true ]; then
274 |                   echo " - Running MavenWrapperDownloader.java ..."
275 |                 fi
276 |                 ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
277 |             fi
278 |         fi
279 |     fi
280 | fi
281 | ##########################################################################################
282 | # End of extension
283 | ##########################################################################################
284 | 
285 | export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
286 | if [ "$MVNW_VERBOSE" = true ]; then
287 |   echo $MAVEN_PROJECTBASEDIR
288 | fi
289 | MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
290 | 
291 | # For Cygwin, switch paths to Windows format before running java
292 | if $cygwin; then
293 |   [ -n "$M2_HOME" ] &&
294 |     M2_HOME=`cygpath --path --windows "$M2_HOME"`
295 |   [ -n "$JAVA_HOME" ] &&
296 |     JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
297 |   [ -n "$CLASSPATH" ] &&
298 |     CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
299 |   [ -n "$MAVEN_PROJECTBASEDIR" ] &&
300 |     MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
301 | fi
302 | 
303 | # Provide a "standardized" way to retrieve the CLI args that will
304 | # work with both Windows and non-Windows executions.
305 | MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
306 | export MAVEN_CMD_LINE_ARGS
307 | 
308 | WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
309 | 
310 | exec "$JAVACMD" \
311 |   $MAVEN_OPTS \
312 |   $MAVEN_DEBUG_OPTS \
313 |   -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
314 |   "-Dmaven.home=${M2_HOME}" \
315 |   "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
316 |   ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
317 | 


--------------------------------------------------------------------------------
/src/main/java/com/lingyi/RootGet/tools/RedisTools.java:
--------------------------------------------------------------------------------
  1 | package com.lingyi.RootGet.tools;
  2 | 
  3 | import com.lingyi.RootGet.entry.Account;
  4 | import com.lingyi.RootGet.entry.Collection;
  5 | import com.lingyi.RootGet.entry.Comment;
  6 | import com.lingyi.RootGet.entry.Video;
  7 | import com.lingyi.RootGet.mapper.video.AccountMapper;
  8 | import com.lingyi.RootGet.mapper.video.CommentMapper;
  9 | import com.lingyi.RootGet.mapper.video.VideoMapper;
 10 | import org.springframework.beans.factory.annotation.Autowired;
 11 | import org.springframework.data.redis.core.Cursor;
 12 | import org.springframework.data.redis.core.ScanOptions;
 13 | import org.springframework.data.redis.core.StringRedisTemplate;
 14 | import org.springframework.stereotype.Service;
 15 | import org.springframework.util.StringUtils;
 16 | import reactor.util.annotation.NonNull;
 17 | 
 18 | import javax.servlet.http.HttpSession;
 19 | import java.lang.reflect.Constructor;
 20 | import java.lang.reflect.Field;
 21 | import java.util.ArrayList;
 22 | import java.util.HashSet;
 23 | import java.util.List;
 24 | import java.util.Set;
 25 | import java.util.concurrent.TimeUnit;
 26 | 
 27 | @Service
 28 | public class RedisTools {
 29 | 
 30 |     private final AccountMapper accountMapper;
 31 |     private final VideoMapper videoMapper;
 32 |     private final CommentMapper commentMapper;
 33 |     private final StringRedisTemplate stringRedisTemplate;
 34 | 
 35 |     @Autowired
 36 |     public RedisTools(AccountMapper accountMapper, VideoMapper videoMapper, CommentMapper commentMapper, StringRedisTemplate stringRedisTemplate) {
 37 |         this.accountMapper = accountMapper;
 38 |         this.videoMapper = videoMapper;
 39 |         this.stringRedisTemplate = stringRedisTemplate;
 40 |         this.commentMapper = commentMapper;
 41 |     }
 42 | 
 43 |     public StringRedisTemplate getRedisTemplate() {
 44 |         return this.stringRedisTemplate;
 45 |     }
 46 | 
 47 |     public String getAccountToken(long id) {
 48 |         return stringRedisTemplate.opsForValue().get("VideoStation:Token:" + id);
 49 |     }
 50 | 
 51 |     public String setAccountToken(long id,long during,TimeUnit timeUnit) {
 52 |         String token = Constant.tokenGenerate(10);
 53 |         stringRedisTemplate.opsForValue().set("VideoStation:Token:" + id, token,during,timeUnit);
 54 |         return token;
 55 |     }
 56 | 
 57 |     /**
 58 |      * @param id 账号id;
 59 |      * @description 从redis中查找账号，若redis中不存在，则查找mysql，若不存在返回null，存在则回写到redis中;
 60 |      */
 61 |     public Account selectAccountInCache(@NonNull long id) {
 62 |         Account account = getFromHashAsObject("VideoStation:Account:" + id, Account.class);
 63 |         //redis中没有数据
 64 |         if (account == null) {
 65 |             //查mysql
 66 |             account = accountMapper.selectOneById(id);
 67 |             //mysql也为查不到
 68 |             if (account == null)
 69 |                 return null;
 70 |             //能查到
 71 |             account.getCreateTime_long();
 72 |             setAccountCache(account, 7, TimeUnit.DAYS);
 73 |         }
 74 |         return account;
 75 |     }
 76 | 
 77 |     public void setAccountCache(@NonNull Account account, long during, TimeUnit timeUnit) {
 78 |         setAsHash("VideoStation:Account:" + account.getId(), account, during, timeUnit);
 79 |     }
 80 | 
 81 |     /**
 82 |      * @param id 视频id
 83 |      * @description 从redis中查找账号，若redis中不存在，则查找mysql，若不存在返回null，存在则回写到redis中
 84 |      */
 85 |     public Video selectVideoInCache(@NonNull String id) {
 86 |         Video video = getFromHashAsObject("VideoStation:Video:" + id, Video.class);
 87 |         //redis中没有数据
 88 |         if (video == null) {
 89 |             //查mysql
 90 |             video = videoMapper.selectOneById(id);
 91 |             //mysql也为查不到
 92 |             if (video == null)
 93 |                 return null;
 94 |             //能查到
 95 |             setVideoCache(video, 7, TimeUnit.DAYS);
 96 |         }
 97 |         return video;
 98 |     }
 99 | 
100 |     public void setVideoCache(@NonNull Video video, long during, TimeUnit timeUnit) {
101 |         setAsHash("VideoStation:Video:" + video.getId(), video, during, timeUnit);
102 |     }
103 | 
104 |     public long videoAddALike(String id) {
105 |         return stringRedisTemplate.opsForHash().increment("VideoStation:Video:" + id, "like", 1);
106 |     }
107 | 
108 |     public long videoAddADisLike(String id) {
109 |         return stringRedisTemplate.opsForHash().increment("VideoStation:Video:" + id, "like", -1);
110 |     }
111 | 
112 |     public long videoAddACollection(String id) {
113 |         return stringRedisTemplate.opsForHash().increment("VideoStation:Video:" + id, "collection", 1);
114 |     }
115 | 
116 |     public long videoAddADisCollection(String id) {
117 |         return stringRedisTemplate.opsForHash().increment("VideoStation:Video:" + id, "collection", -1);
118 |     }
119 | 
120 |     public Comment selectCommentInCache(long id) {
121 |         Comment comment = getFromHashAsObject("VideoStation:Comment:" + id, Comment.class);
122 |         if (comment == null) {
123 |             comment = commentMapper.getCommentsById(id);
124 |             if (comment == null)
125 |                 return null;
126 |             setCommentCache(comment, 7, TimeUnit.DAYS);
127 |         }
128 |         return comment;
129 |     }
130 | 
131 |     public void setCommentCache(Comment comment, long during, TimeUnit timeUnit) {
132 |         setAsHash("VideoStation:Comment:" + comment.getId(), comment, during, TimeUnit.DAYS);
133 |     }
134 | 
135 |     /**
136 |      * 从redis中取出hash并包装成对应的类型
137 |      * 没有 返回null
138 |      *
139 |      * @param key  要获取的redis key
140 |      * @param type 要获取的对象类型
141 |      **/
142 |     public <T> T getFromHashAsObject(String key, Class<T> type) {
143 |         if (!StringUtils.hasText(key)) throw new NullPointerException("key must not be null");
144 |         if (type == null) throw new NullPointerException("type must not be null");
145 |         if (!stringRedisTemplate.hasKey(key)) return null;
146 |         //获取类属性
147 |         Field[] fields = type.getDeclaredFields();
148 |         T instance;
149 |         Constructor<T> constructor;
150 |         try {
151 |             //创建实例
152 |             constructor = type.getConstructor();
153 |             instance = constructor.newInstance();
154 |             //从redis获取 并设置属性
155 |             for (Field field : fields) {
156 |                 field.setAccessible(true);
157 |                 String name = field.getName();
158 |                 String field_type = field.getType().getSimpleName();
159 |                 String value_string = (String) stringRedisTemplate.opsForHash().get(key, name);
160 |                 if (value_string == null) {
161 |                     field.set(instance, null);
162 |                     continue;
163 |                 }
164 |                 switch (field_type) {
165 |                     case "String":
166 |                         field.set(instance, value_string);
167 |                         break;
168 |                     case "short":
169 |                         field.set(instance, Short.parseShort(value_string));
170 |                         break;
171 |                     case "Integer":
172 |                         field.set(instance, Integer.valueOf(value_string));
173 |                         break;
174 |                     case "int":
175 |                         field.set(instance, Integer.parseInt(value_string));
176 |                         break;
177 |                     case "Long":
178 |                         field.set(instance, Long.valueOf(value_string));
179 |                         break;
180 |                     case "long":
181 |                         field.set(instance, Long.parseLong(value_string));
182 |                         break;
183 |                     case "Double":
184 |                         field.set(instance, Double.valueOf(value_string));
185 |                         break;
186 |                     case "float":
187 |                         field.set(instance, Float.valueOf(value_string));
188 |                         break;
189 |                     case "boolean":
190 |                         field.set(instance, Boolean.parseBoolean(value_string));
191 |                         break;
192 |                 }
193 |             }
194 |         } catch (Exception e) {
195 |             e.printStackTrace();
196 |             throw new ClassCastException("从redis中取出的数据无法包装成对应的类型：" + type.getName());
197 |         }
198 |         return instance;
199 |     }
200 | 
201 |     /**
202 |      * 将一个对象设置成hash类型放入redis
203 |      *
204 |      * @param key 要设置的key
205 |      * @param obj 要设置的对象
206 |      */
207 |     public void setAsHash(String key, Object obj, long during, TimeUnit timeUnit) {
208 |         if (!StringUtils.hasText(key)) throw new NullPointerException("key must not be null");
209 |         if (obj == null) throw new NullPointerException("obj must not be null");
210 |         if (stringRedisTemplate.hasKey(key))
211 |             throw new RuntimeException("key exists");
212 |         Field[] fields = obj.getClass().getDeclaredFields();
213 |         try {
214 |             for (Field field : fields) {
215 |                 field.setAccessible(true);
216 |                 String field_type = field.getType().getSimpleName();
217 |                 if (field.get(obj) == null) {
218 |                     stringRedisTemplate.opsForHash().put(key, field.getName(), "null");
219 |                     continue;
220 |                 }
221 |                 switch (field_type) {
222 |                     case "String":
223 |                         stringRedisTemplate.opsForHash().put(key, field.getName(), field.get(obj));
224 |                         break;
225 |                     case "long":
226 |                     case "Long":
227 |                     case "int":
228 |                     case "Integer":
229 |                     case "Double":
230 |                     case "Float":
231 |                     case "Char":
232 |                     case "boolean":
233 |                         stringRedisTemplate.opsForHash().put(key, field.getName(), String.valueOf(field.get(obj)));
234 |                         break;
235 |                 }
236 |             }
237 |             //设置过期时间
238 |             if (during != -1 && timeUnit != null)
239 |                 stringRedisTemplate.expire(key, during, timeUnit);
240 |         } catch (Exception e) {
241 |             e.printStackTrace();
242 |         }
243 |     }
244 | 
245 |     /**
246 |      * 分布式锁
247 |      * 一分钟只能请求一次
248 |      */
249 |     public boolean setLock(String id, String type) {
250 |         if (id == null || type == null)
251 |             throw new NullPointerException("id and type must not be null");
252 |         return stringRedisTemplate.opsForValue().setIfAbsent("VideoStation:" + type + "Lock:" + id, "1", 1, TimeUnit.MINUTES);
253 |     }
254 | 
255 |     /**
256 |      * 获取分布式锁剩余时间
257 |      */
258 |     public long getLockTTL(String id, String type) {
259 |         if (id == null || type == null)
260 |             throw new NullPointerException("id and type must not be null");
261 |         return stringRedisTemplate.opsForValue().getOperations().getExpire("VideoStation:" + type + "Lock:" + id);
262 |     }
263 | 
264 |     /**
265 |      * 不重复的从redis中获取video
266 |      *
267 |      * @param size    要获取的数量 若剩余数量小于size则返回剩余数量
268 |      * @param isFirst 首次获取会清除所有已获取的video，isFirst = false 则继续获取未获取的video
269 |      */
270 |     public Set<Video> getVideos(int size, HttpSession session, boolean isFirst) {
271 |         //首次加载全部清除
272 |         if (isFirst) {
273 |             Set<String> members = stringRedisTemplate.opsForSet().members("VideoStation:VideoSet:" + session.getId());
274 |             for (String member : members) {
275 |                 stringRedisTemplate.opsForSet().remove("VideoStation:VideoSet:" + session.getId(), member);
276 |             }
277 |         }
278 | 
279 |         //获取redis的key
280 |         Set<String> keys = getKeys("VideoStation:Video:*");
281 |         if (keys.size() < size) size = keys.size();
282 |         //本次获取的video
283 |         Set<Video> now_videos = new HashSet<>();
284 |         for (String key : keys) {
285 |             Video video = getFromHashAsObject(key, Video.class);
286 |             Boolean isMember = stringRedisTemplate.opsForSet().isMember("VideoStation:VideoSet:" + session.getId(), String.valueOf(video.getId()));
287 |             //若已经获取过了
288 |             if (isMember)
289 |                 continue;
290 |             else {
291 |                 stringRedisTemplate.opsForSet().add("VideoStation:VideoSet:" + session.getId(), String.valueOf(video.getId()));
292 |                 stringRedisTemplate.expire("VideoStation:VideoSet:" + session.getId(), 1, TimeUnit.HOURS);
293 |                 now_videos.add(video);
294 |             }
295 |             if (now_videos.size() == size) return now_videos;
296 |         }
297 |         return now_videos;
298 |     }
299 |     public List<Collection> getCollection(long uid){
300 |         //收藏集合
301 |         List<Collection> collections = new ArrayList<>();
302 |         //获取所有收藏夹
303 |         ScanOptions options = ScanOptions.scanOptions()
304 |                 .match("VideoStation:Collection:"+uid+":*")
305 |                 .count(1000)
306 |                 .build();
307 |         Cursor<String> cursor = stringRedisTemplate.scan(options);
308 |         List<String> keys = new ArrayList<>();
309 |         while(cursor.hasNext()){
310 |             String key = cursor.next();
311 |             keys.add(key);
312 |         }
313 |         //查找视频并添加进集合
314 |         for(int i=0;i<keys.size();i++){
315 |             Collection collection = new Collection();
316 |             collection.setName(keys.get(i).split(":")[3]);
317 |             Set<Video> videos = new HashSet<>();
318 |             Set<String> members = stringRedisTemplate.opsForSet().members(keys.get(i));
319 |             for (String member : members) {
320 |                 Video video = getFromHashAsObject("VideoStation:Video:"+member, Video.class);
321 |                 if (video==null){
322 |                     stringRedisTemplate.opsForSet().remove(keys.get(i),member);
323 |                 }else videos.add(video);
324 |             }
325 |             collection.setVideos(videos);
326 |             collections.add(collection);
327 |         }
328 |         return collections;
329 |     }
330 |     public void addToCollection(long uid,long videoId,String collectionName){
331 |         stringRedisTemplate.opsForSet().add("VideoStation:Collection:"+uid+":"+collectionName,String.valueOf(videoId));
332 |         videoAddACollection(String.valueOf(videoId));
333 |     }
334 |     public void removeFromCollection(long uid,long videoId,String collectionName){
335 |         stringRedisTemplate.opsForSet().remove("VideoStation:Collection:"+uid+":"+collectionName,String.valueOf(videoId));
336 |         videoAddADisCollection(String.valueOf(videoId));
337 |     }
338 |     public Set<String> getKeys(String match){
339 |         //获取redis的key
340 |         Set<String> keys = new HashSet<>();
341 |         ScanOptions options = ScanOptions.scanOptions().count(1000L).match(match).build();
342 |         Cursor<String> cursor = stringRedisTemplate.scan(options);
343 |         while (cursor.hasNext()) {
344 |             String key = cursor.next();
345 |             keys.add(key);
346 |         }
347 |         return keys;
348 |     }
349 |     public void renameKey(String key,String newKey){
350 |         stringRedisTemplate.rename(key,newKey);
351 |     }
352 |     public long addOnePlay(String id){
353 |         return stringRedisTemplate.opsForHash().increment("VideoStation:Video:"+id,"play",1);
354 |     }
355 | }
356 | 


--------------------------------------------------------------------------------