import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.data.redis.core.index.Indexed;

@RedisHash("persons")  // 指定操作实体类对象在Redis数据库中的存储空间
public class Person {

    @Id        // 标识实体类主键
    private String id;

    @Indexed  // 标识对应属性在Redis数据库中生成二级索引
    private String firstname;

    @Indexed
    private String lastname;

    public Person() {
    }

    public Person(String firstname, String lastname) {
        this.firstname = firstname;
        this.lastname = lastname;
    }
	// 自行添加 set get toString方法
}

import com.itheima.domain.Person;
import org.springframework.data.repository.CrudRepository;
public interface PersonRepository extends CrudRepository<Person, String> {

}

import site.hikki.domain.Person;
import site.hikki.repository.PersonRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class RedisTests {

    @Autowired
    private PersonRepository repository;

    @Test
    public void savePerson() {
        Person person =new Person("小码","同学");
        // 向Redis数据库添加数据
        Person save = repository.save(person);
        System.out.println(save);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> template = new RedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
            GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer=new GenericJackson2JsonRedisSerializer();
            template.setKeySerializer(stringRedisSerializer);
            template.setValueSerializer(genericJackson2JsonRedisSerializer);
            template.setHashKeySerializer(stringRedisSerializer);
            template.setHashValueSerializer(genericJackson2JsonRedisSerializer);
            return template;
        }
}

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.util.concurrent.TimeUnit;

@Component
public class RedisService {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 判断key是否存在
     */
    public boolean hasKey(String key){
        if (StringUtils.hasLength(key)){
            return redisTemplate.hasKey(key);
        }
        return false;
    }

    /**
     * 删除key
     */
    public boolean delKey(String key){
        if (StringUtils.hasLength(key)){
            return redisTemplate.delete(key);
        }
        return false;
    }

    /**
     * 设置key过期时间
     * 形参timeUnit常见单位如下：
     * TimeUnit.DAYS 天
     * TimeUnit.HOURS 小时
     * TimeUnit.MINUTES 分钟
     * TimeUnit.SECONDS 秒
     */
    public boolean expTime(String key, long timeout, TimeUnit timeUnit){
        if (StringUtils.hasLength(key)){
            return redisTemplate.expire(key,timeout,timeUnit);
        }
        return false;
    }


    /**
     * 设置 -Set类型key
     */
    public <T> boolean set(String key,T value){
        if (StringUtils.hasLength(key)){
            redisTemplate.opsForValue().set(key,value);
            return true;
        }
        return false;
    }

    /**
     * get -Set 类型key
     */
    public <T> T get(String key){
        ValueOperations<String,T> valueOperations = redisTemplate.opsForValue();
        return valueOperations.get(key);
    }

    // -----------------------
    /**
     * 添加缓存
     * @param key
     * @param value
     * @return
     */
    public boolean redisCache(String key,Object value){
        if (hasKey(key)){
            return true;
        }else {
            return set(key,value);
        }
    }
}

import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.data.redis.core.index.Indexed;

@RedisHash("persons")  // 指定操作实体类对象在Redis数据库中的存储空间
public class Person {

    @Id        // 标识实体类主键
    private String id;

    @Indexed  // 标识对应属性在Redis数据库中生成二级索引
    private String firstname;

    @Indexed
    private String lastname;

    public Person() {
    }

    public Person(String firstname, String lastname) {
        this.firstname = firstname;
        this.lastname = lastname;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getFirstname() {
        return firstname;
    }

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", firstname='" + firstname + '\'' +
                ", lastname='" + lastname + '\'' +
                '}';
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import site.hikki.pojo.Person;
import site.hikki.template.RedisService;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@SpringBootTest(classes = Application.class)
public class RedisTemplateTest {

    @Resource
    RedisService redisService;

    /**
     * 添加key
     */
    @Test
    public void addKey(){
        String key ="test";
        boolean b = redisService.set(key, "this is value");
        System.out.println(b);
    }

    /**
     * 获取key
     */
    @Test
    public void getKey(){
        String test = redisService.get("test");
        System.out.println(test);
    }


    /***
     * 删除一个key
     */
    @Test
    public void delKey(){
        String key = "test2";
        boolean b = redisService.delKey(key);
        System.out.println(b);
    }


    /**
     * 设置Key并设置过期时间
     */
    @Test
    public void setKeyAndTime(){
        String key = "test2";
        boolean test2 = redisService.set(key, "this is test2");
        // 给 test2的key设置过期时间为1分钟，一分钟后自动销毁test2
        boolean b = redisService.expTime(key, 1, TimeUnit.MINUTES);
        System.out.println("set key:"+test2);
        System.out.println("set time:"+b);
    }

    /**
     * 设置实体类类型的key
     */
    @Test
    public void setEntity(){
        String key = "test3";
        Person person = new Person();
        person.setFirstname("小黑子");
        person.setId("1");
        person.setLastname("小白子");
        boolean b = redisService.set(key, person);
        System.out.println(b);
    }

    /**
     * 获取实体类的key
     */
    @Test
    public void getEntity(){
        String key = "test3";
        Person person = redisService.get(key);
        System.out.println(person.toString());
    }
}

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import java.util.List;

@Data
@Document()
public class Result {

    @Id
    private String id; // 主键ID存储到数据库默认是ObjectId()

    private List<Comment> data=null; //评论内容

    private String more=null;

    private Integer count=0; //data数组下条数,也就是该文章评论数量
}

import lombok.Data;
import org.springframework.data.annotation.Id;
import java.util.Date;
import java.util.List;

/**
 * 父评论 也叫根评论
 */
@Data
public class Comment {
    @Id
    private String id; //主键
    private String nick; // 用户别名
    private String avatar; // 头像URL
    private String mailMd5; // 邮箱Hash
    private String link; // 用户网站地址
    private String comment; // 评论内容
    private String os; // 评论所用系统
    private String browser; // 浏览器版本
    private String ipRegion; // 发布者IP地址
    private boolean master;// 是否是博客这座
    private Integer like=0; // 点赞数量
    private List<SubComment> replies; // 子评论
    private Integer top; // 置顶数量，数值越小，置顶优先权越高
    private boolean isSpam=false; // 是否是垃圾邮件
    private Date created=new Date(); // 创建时间

}

import lombok.Data;
import org.springframework.data.annotation.Id;
import java.util.Date;

@Data
public class SubComment {
    @Id
    private String id; //主键
    private String nick; // 用户别名
    private String avatar; // 头像URL
    private String mailMd5; // 邮箱Hash
    private String link; // 用户网站地址
    private String comment; // 评论内容
    private String os; // 评论所用系统
    private String browser; // 浏览器版本
    private String ipRegion; // IP 地址
    private String master;// 是否是博客这座
    private Integer like; // 点赞数量
    private String rid; //该评论的根父评论
    private String pid; //要回复的作者ID
    private String ruser; //该评论回复的是谁
    private boolean isSpam=false; //该邮箱是否是垃圾邮箱
    private Date created=new Date(); // 创建时间
}

import site.hikki.pojo.cm.Comment;
import site.hikki.pojo.cm.Result;
import site.hikki.pojo.cm.SubComment;
import java.util.List;

public interface CommentDao {

    Result initResult();

    Object addComment(String rootId,Comment comment);

    Object delComment(String rootId,String commentId);

    Object updateComment(String rootId,String mailMd5, String newMailMd5);

    List<Result> findAllComment();

    List<Comment> findCommentById(String id);

    Object addSubComment(String rootId,String commentId,SubComment subComment);

}

import com.mongodb.client.result.UpdateResult;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.*;
import org.springframework.data.mongodb.core.aggregation.*;
import org.springframework.data.mongodb.core.query.*;
import org.springframework.stereotype.Repository;
import site.hikki.dao.CommentDao;
import site.hikki.pojo.cm.*;
import java.util.ArrayList;
import java.util.List;

@Repository
public class CommentDaoImpl implements CommentDao {
    @Autowired
    MongoTemplate mongoTemplate;

    /**
     * 初始化每一条博客文章
     */
    @Override
    public Result initResult() {
        Result result = new Result();
        result.setCount(0);
        result.setMore("");
        result.setData(new ArrayList<>());
        return mongoTemplate.insert(result);
    }

    /**
     * 添加父评论
     */
    @Override
    public Object addComment(String rootId,Comment comment) {
        // 此处的
        Query query = new Query(Criteria.where("id").is(rootId));
        Update update = new Update().push("data",comment);
        UpdateResult result = mongoTemplate.updateFirst(query, update, Result.class);
        return result;
    }

    /**
     *
     * 删除时，如果是自带生成的_id,不需要添加 ObjectId()
     * 直接使用 ObjectId 的值即可
     * @param rootId 每条评论对应的文档ID
     * @param commentId 父评论
     * @return
     */
    @Override
    public Object delComment(String rootId,String commentId) {
        Query  query = new Query(Criteria.where("id").is(rootId));
        Update update = new Update().pull("data", Query.query(Criteria.where("_id").is(commentId)));
        UpdateResult updateResult = mongoTemplate.updateMulti(query, update, Result.class);
        return updateResult;
    }

    /**
     * 根据父评论Id 修改父评论邮件 Hash
     * @param rootId Result根ID
     * @param mailMd5 邮件原Hash值
     * @param newMailMd5 需要更换后的邮件Hash值
     */
    @Override
    public Object updateComment(String rootId,String mailMd5, String newMailMd5) {
        Query query = new Query(Criteria.where("id").is(rootId));
        // 使用elemMatch操作符选择匹配的数组元素
        query.addCriteria(Criteria.where("data").elemMatch(Criteria.where("mailMd5").is(mailMd5)));
        // 使用set运算符更新所选数组元素的“mailMd5”字段
        Update update = new Update().set("data.$.mailMd5", newMailMd5);
        UpdateResult result = mongoTemplate.updateMulti(query, update, Result.class);
        return result;
    }


    /**
     * 查询整个Comment文档数据
     */
    @Override
    public List<Result> findAllComment() {
        return mongoTemplate.findAll(Result.class);
    }

    /**
     * 根据评论ID查询
     * @param commentId 父评论ID
     */
    @Override
    public List<Comment> findCommentById(String commentId) {
        Aggregation aggregation = Aggregation.newAggregation(
                Aggregation.unwind("data"),
                Aggregation.match(Criteria.where("data._id").is(new ObjectId(commentId))),
                Aggregation.project()
                        .and("data.nick").as("nick")
                        .and("data.avatar").as("avatar")
                        .and("data.mailMd5").as("mailMd5")
                        .and("data.link").as("link")
                        .and("data.comment").as("comment")
                        .and("data.os").as("os")
                        .and("data.browser").as("browser")
                        .and("data.ipRegion").as("ipRegion")
                        .and("data.master").as("master")
                        .and("data.like").as("like")
                        .and("data.replies").as("replies")
                        .and("data.top").as("top")
                        .and("data.isSpam").as("isSpam")
                        .and("data.created").as("created")
        );
        AggregationResults<Comment> result = mongoTemplate.aggregate(aggregation, "result", Comment.class);
        return result.getMappedResults();
    }

    /**
     * 添加子评论
     * 子评论存储在replies下
     * @param rootId Result文档根Id
     * @param commentId 父评论ID
     * @param subComment 子评论内容
     * @return UpdateResult
     */
    public Object addSubComment(String rootId,String commentId,SubComment subComment){
        Query query = Query.query(Criteria.where("_id").is(rootId));
        query.addCriteria(Criteria.where("data._id").is(commentId));
        Update update = new Update().push("data.$.replies", subComment);
        UpdateResult result = mongoTemplate.updateFirst(query, update, Result.class);
        return result;
    }
}

import org.bson.types.ObjectId;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import site.hikki.Application;
import site.hikki.pojo.cm.*;
import java.util.ArrayList;
import java.util.List;

@SpringBootTest(classes = Application.class)
class CommentDaoTest {

    @Autowired
    CommentDao commentDao;

    //TODO: 该测试必须先运行 initResult 方法，自动创建 Comment 文档

    @Test
    public void initResult(){
        Result result = commentDao.initResult();
        System.out.println(result);
    }


    @Test
    void addComment() {
        Comment comment = new Comment();
        comment.setId(new ObjectId().toString());
        comment.setNick("小码同学");
        comment.setAvatar("https://blog.hikki.site/avatar.png");
        comment.setMailMd5("646c7393588d857cce5479df");
        comment.setLink("https://blog.hikki.site");
        comment.setComment("这博客好棒啊");
        comment.setOs("Android");
        comment.setBrowser("Firefox/113.0");
        comment.setIpRegion("192.168.2.8");
        comment.setMaster(true);
        comment.setReplies(new ArrayList<>());
        comment.setLike(5);
        comment.setTop(1);
        ArrayList<Comment> comments = new ArrayList<>();
        comments.add(comment);
        String rootId = "646d69a1dc3b9f57424e311b";
        commentDao.addComment(rootId,comment);
    }


    /**
     * 删除父评论
     *
     */
    @Test
    void delComment() {
        String rootId="646d69a1dc3b9f57424e311b";
        String commentId="646d69ef9c64d41e198f7e6b";
        Object o = commentDao.delComment(rootId, commentId);
        System.out.println(o);
    }

    /**
     * 修改data下的父评论的邮箱HAsh
     */
    @Test
    void updateComment() {
        String rootId="646d69a1dc3b9f57424e311b"; //  Result根ID
        String mailMd5="646c7393588d857cce5479df"; // 邮件原Hash值
        String newMailMd5="123456789"; // 需要更换后的邮件Hash值
        Object o = commentDao.updateComment(rootId,mailMd5,newMailMd5);
        System.out.println(o);
    }

    @Test
    void findAllComment() {
        List<Result> allComment = commentDao.findAllComment();
        for (Result c : allComment) {
            System.out.println(c);
        }
    }

    @Test
    void findCommentById() {
        // 根据父评论ID查询
        Object commentById = commentDao.findCommentById("646d78c4cac1fa60cf0d9e42");
        System.out.println(commentById);
    }

    @Test
    void addSubComment(){
        SubComment comment = new SubComment(); // 子评论内容
        comment.setId(new ObjectId().toString()); // 子评论自动生成ID
        comment.setNick("小码同学");
        comment.setAvatar("https://blog.hikki.site/avatar.png");
        comment.setMailMd5("646c7393588d857cce5479df");
        comment.setLink("https://blog.hikki.site");
        comment.setComment("这博客好棒啊");
        comment.setOs("Android");
        comment.setBrowser("Firefox/113.0");
        comment.setIpRegion("192.168.2.8");
        comment.setLike(5);

        String rootId="646d69a1dc3b9f57424e311b"; //Result文档根Id
        String commentId="646d78c4cac1fa60cf0d9e42"; //父评论ID
        Object o = commentDao.addSubComment(rootId,commentId,comment);
        System.out.println(o);
    }

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import site.hikki.service.MailService;


@RestController
@RequestMapping
public class SendEmail {

    @Autowired
    private MailService send;
    @GetMapping("/send")
    public String send(){
        String code ="46511";
        send.sendMail(code,"1341151056@qq.com");
        return "hello 小码同学！！！";
    }

    @GetMapping("/get")
    public String getCOde(){
        System.out.println(send.getCode());
        return send.getCode();
    }
}