SpringData(二)

2020-09-27

1. SpringData Redis

1.1 SpringData Redis 简介

Redis是一个基于内存的数据结构存储系统，它可以用作数据库或者缓存。它支持多种类型的数据结构，这些数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和Zset（有序集合）。

SpringData Redis的作用是通过一段简单的配置即可访问redis服务，它的底层是对java提供的redis开发包(比如jedis等)进行了高度封装，主要提供了如下功能：

连接池自动管理，提供了一个高度封装的 RedisTemplate类,基于这个类的对象可以对redis进行各种操作
针对 jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
- ValueOperations ：简单字符串类型数据操作
- SetOperations ：set类型数据操作
- ZSetOperations ：zset类型数据操作
- HashOperations ：map类型的数据操作
- ListOperations ：list类型的数据操作

1.2 Redis 环境搭建

1.2.1 安装redis的依赖环境

1	yum -y install gcc automake autoconf libtool make

1.2.2 上传安装包

获取到安装包,并将它上传到linux的/usr/local/src/目录下

1.2.3 解压

解压安装包,得到一个redis-5.0.4目录

1	tar -zxvf redis-5.0.4.tar.gz

1.2.4 编译

进入redis目录,在目录下执行make命令

1
2
3

cd redis-5.0.4

make

1.2.5 安装

执行安装命令,注意此处指定了安装目录为/usr/local/redis

1	make PREFIX=/usr/local/redis install

1.2.6 复制配置文件

将配置文件复制到redis的安装目录的bin目录下

1
2
3

cd /usr/local/redis/bin/

cp /usr/local/src/redis-5.0.4/redis.conf ./

1.2.7 修改 redis的配置文件

修改redis的配置文件,将注解绑定和保护模式关闭,方便我们从客户端连接测试

1	vim redis.conf

1.2.8 启动 redis服务

1	./src/redis-server redis.conf

1.3 SpringData Redis 入门案例

1.3.1 创建工程，引入坐标

<dependencies>
    <!--jedis-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.3</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>2.1.8.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.8</version>
    </dependency>
</dependencies>

1.3.2 创建配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置Jedis连接池参数-->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--最大连接数-->
        <property name="maxTotal" value="30"/>
        <!--最大空闲连接数-->
        <property name="maxIdle" value="20"/>
        <!--最小空闲连接数-->
        <property name="minIdle" value="10"/>
    </bean>

    <!--配置Jedis连接工厂-->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:hostName="192.168.142.128" p:port="6379" p:poolConfig-ref="jedisPoolConfig"
    />

    <!--配置Redis的模板-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <!--配置jedis的连接工厂,目的是为了获取jedis连接-->
        <property name="connectionFactory" ref="jedisConnectionFactory"/>

        <!--配置非hash类型的序列化器-->
        <!--<property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>-->
    </bean>
</beans>

1.3.3 测试

/**
 * SpringData Redis 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 测试:向redis保存一条数据
     */
    @Test
    public void testSave() {
        //存入数据
        redisTemplate.opsForValue().set("name", "test");
        //查询数据
        String name = (String) redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }
}

1.4 SpringData Redis 的序列化器

通过Redis提供的客户端查看入门案例中存入redis的数据

这时候会发现，存入的数据并不是简单的字符串，而是一些类似于二进制的数据，这是怎么回事呢？

原来，SpringData Redis在保存数据的时候，底层有一个序列化器在工作，它会将要保存的数据（键和值）按照一定的规则进行序列化操作后再进行存储。spring-data-redis提供如下几种序列化器：

StringRedisSerializer: 简单的字符串序列化
GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
Jackson2JsonRedisSerializer: 序列化对象为json字符串
GenericJackson2JsonRedisSerializer: 功能同上,但是更容易反序列化
OxmSerializer: 序列化对象为xml字符串
JdkSerializationRedisSerializer: 序列化对象为二进制数据

RedisTemplate默认使用的是JdkSerializationRedisSerializer对数据进行序列化。

那么如何选择自己想要的序列化器呢？SpringData提供了两种方式：

1、通过配置文件配置

<!--配置Redis的模板-->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <!--配置jedis的连接工厂,目的是为了获取jedis连接-->
    <property name="connectionFactory" ref="jedisConnectionFactory"/>

    <!--配置非hash类型的序列化器-->
    <property name="keySerializer">
        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
    <property name="valueSerializer">
        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
</bean>

2、通过RedisTemplate设定

@Test
public void testSave2() {
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new StringRedisSerializer());

    //获取操作简单字符串类型数据的数据句柄
    ValueOperations operations = redisTemplate.opsForValue();
    operations.set("name3", "test");

    //查询数据
    String name = (String) redisTemplate.opsForValue().get("name3");
    System.out.println(name);
}

1.5 SpringData Redis 运行原理分析

我们从入门案例中已经知道SpringData Redis操作Redis服务器只要是通过RestTemplate实现的，那么RestTemplate底层到底是如何操作redis的呢，下面我们通过源码追踪的形式看一看。

1、首先看配置文件中关于RestTemplate的bean的配置，可以看到在RedisTemplate的bean声明中注入了一个JedisConnectionFactory实例，顾名思义，这个连接工厂是用来获取Jedis连接的，那么通过这种方式RedisTemplate就可以拿到操作Redis服务器的句柄了。

2、使用debug运行入门案例，观察创建好的RestTemplate实例，可以看到里面主要有序列化器和redis的连接信息，基于这些，我们就可以对redis进行操作了

3 、跟踪进入set方法，我们可以看到set方法中使用了一个connection来进行操作，这个connection的类型是JedisConnetion，而这个connection肯定是通过配置文件配置的JedisConnectionFactory产生的，也就是底层开始调用jedis的api了。

4 、继续追踪set方法，选择JedisStringCommands实现

5 、继续之宗set方法，可以看到底层已经获取到了jedis的实例，再调用set方法已经在调jedis的set了

6 、再追踪一步，就会发现，底层最终调用的是jedis的原生API，setCommand方法，这个方法就是jedis提供的对redis的各种操作命令了。

至此，我们的分析完毕。得到的结论就是：

SpringData提供redisTemplate就是在原生的Jedis或者其他操作redis的技术上做的一层封装，它屏蔽掉了这些原生技术的实现细节，统一了调用接口，使得我们的操作更加简单明了。

1.6 SpringData Redis 常见操作

本章节我们来学习如何使用SpringData Redis来操作Redis的各种数据类型.

在Redis中有五种常见类型,SpringData Redis对每一种数据类型都提供了一个xxxOperations的API,他们分别是:

ValueOperations : 用来操作字符串类型数据
HashOperations: 用来操作hash类型数据
ListOperations: 用来操作list类型数据
SetOperations: 用来操作set类型数据
ZSetOperations: 用来操作zset类型数据

1.6.1 String类型

/**
 * String类型
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisStringTest {

    ValueOperations<String, String> operations = null;
    @Autowired
    private RedisTemplate redisTemplate;

    @Before
    public void init() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        operations = redisTemplate.opsForValue();
    }

    @Test
    public void testSet() {
        //向数据库中保存name--heima
        operations.set("name", "heima");

        //相关数据库保存name1--heima1  有效时间为10s
        operations.set("name1", "heima1", 10, TimeUnit.SECONDS);

        //替换 heima    --->   heXXa   offset 索引位置是从0开始
        operations.set("name", "XX", 2);

        //当key不存在的时候,执行保存操作;当key存在的时候,什么都不做
        operations.setIfAbsent("name1", "heima");

        //批量保存
        Map map = new HashMap();
        map.put("name2", "heima2");
        map.put("name3", "heima3");
        map.put("name4", "heima4");

        operations.multiSet(map);


        //追加 当key存在时,会执行追加操作;当key不存在时,会执行保存操作
        operations.append("name5", "Heima");
    }

    @Test
    public void testGet() {
        //根据key获取value
        String value = operations.get("name");
        System.out.println(value);//heXXaHeima

        //首先根据key获取value,然后再根据value进行截取,从start位置截取到end位置[包含start和end]
        String value2 = operations.get("name", 5, 7);
        System.out.println(value2);//heXXaHeima-->Hei

        //批量获取
        List<String> keys = new ArrayList<>();
        keys.add("name2");
        keys.add("name3");
        keys.add("name4");
        List<String> values = operations.multiGet(keys);
        for (String s : values) {
            System.out.println(s);
        }

        //根据key获取value的长度
        Long size = operations.size("name");
        System.out.println(size);
    }

    //自增
    @Test
    public void testIncrement() {
        operations.set("age", "18");
        operations.increment("age");//自增1--->19
        System.out.println(operations.get("age"));
        operations.increment("age", 5);//自增5
        System.out.println(operations.get("age"));//---->24

        //自减
        operations.decrement("age");
    }

    //删除
    @Test
    public void testDelete() {
        //单个删除
        redisTemplate.delete("name");

        List<String> keys = new ArrayList<>();
        keys.add("name2");
        keys.add("name3");
        keys.add("name4");

        //批量删除
        redisTemplate.delete(keys);
    }
}

1.6.2 Hash 类型

/**
 * Hash类型
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisHashTest {

    HashOperations<String, String, Article> operations = null;
    @Autowired
    private RedisTemplate redisTemplate;

    @Before
    public void init() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());

        operations = redisTemplate.opsForHash();
    }

    /**
     * 保存
     */
    @Test
    public void testPut() {
        Article article = new Article();
        article.setTitle("测试");
        article.setAuthor("程序员");
        article.setCreateTime(new Date());

        operations.put("article", "3", article);
    }


    /**
     * 获取
     */
    @Test
    public void testGet() {
        //判断hashkey是否存在
        Boolean flag = operations.hasKey("article", "3");
        System.out.println(flag);

        //根据key和hashkay获取操作
        Article article = operations.get("article", "2");
        System.out.println(article);


        //根据key获取所有的hashkey
        Set<String> set = operations.keys("article");
        for (String s : set) {
            System.out.println(s);
        }

        List<Article> articles = operations.values("article");
        for (Article art : articles) {
            System.out.println(art);
        }

        Map<String, Article> map = operations.entries("article");
        for (Map.Entry<String, Article> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

    /**
     * 删除
     */
    @Test
    public void testDelete() {
        //当hash中的数据全部被删除后,整个hash就没了
        operations.delete("article", "2", "3");
    }
}

1.6.3 List 类型

/**
 * List类型
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisListTest {

    ListOperations<String, String> operations = null;
    @Autowired
    private RedisTemplate redisTemplate;

    @Before
    public void init() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        operations = redisTemplate.opsForList();
    }

    /**
     * 增加
     */
    @Test
    public void testAdd() {
        //从左边添加一个元素
        operations.leftPush("students", "zhangsan");
        //从左边添加多个元素
        operations.leftPushAll("students", "lisi", "wangwu", "zhaoliu");


        //从右边添加一个元素
        operations.rightPush("students", "zhangsan1");
        //从右边添加多个元素
        operations.rightPushAll("students", "lisi", "wangwu", "zhaoliu");
    }

    /**
     * 查询
     */
    @Test
    public void testFind() {
        //根据key和索引进行查询
        //0和正数代表从左边开始    0  1  2
        //负数代表从右边开始       -1   -2  -3
        String student = operations.index("students", 1);
        System.out.println(student);

        String student1 = operations.index("students", -2);
        System.out.println(student1);

        //范围查询
        //根据key  [start,end]  包括首尾
        List<String> students = operations.range("students", 0, 2);
        for (String s : students) {
            System.out.println(s);
        }
    }

    /**
     * 删除
     */
    @Test
    public void testRemove() {
        //从左边删除第一个元素
        //String s = operations.leftPop("students");

        //从右边删除第一个元素
        //operations.rightPop("students");


        // count > 0：删除左边起第几个等于指定值的元素
        // count < 0：删除右边起第几个等于指定值的元素
        // count = 0：删除所有等于value的元素。
        //删除左边起第二个wangwu
        operations.remove("students", 2, "wangwu");
    }

}

1.6.4 Set 类型

/**
 * Set类型
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisSetTest {

    SetOperations<String, String> operations = null;
    @Autowired
    private RedisTemplate redisTemplate;

    @Before
    public void init() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        operations = redisTemplate.opsForSet();
    }

    /**
     * 增加
     */
    @Test
    public void testAdd() {
        operations.add("students", "zhangsan", "lisi", "wangwu", "zhangsan");
    }

    /**
     * 查询
     */
    @Test
    public void testFind() {
        //查询所有元素
        Set<String> students = operations.members("students");
        for (String student : students) {
            System.out.println(student);
        }

        //随机获取一个元素
        String student = operations.randomMember("students");
        System.out.println(student);

        //随机多个元素[可能会重复]
        List<String> stus = operations.randomMembers("students", 2);
        for (String stu : stus) {
            System.out.println(stu);
        }
    }

    /**
     * 删除
     */
    @Test
    public void testRemove() {
        //移除元素,并返回移除成功个数
        Long count = operations.remove("students", "zhangsan", "wangwu", "sunliu");
        System.out.println(count);

        //随机移除指定集合中的多少个元素
        List<String> students = operations.pop("students", 2);
        for (String student : students) {
            System.out.println(student);
        }
    }

    /**
     * 多集合操作
     */
    @Test
    public void testMoreSet() {
        operations.add("names1", "zhangsan", "li", "wangwu");
        operations.add("names2", "zhangsan", "li", "zhaoliu");

        //取交集
        Set<String> sets1 = operations.intersect("names1", "names2");
        for (String s : sets1) {
            System.out.println(s);
        }

        //取并集
        Set<String> sets2 = operations.union("names1", "names2");
        for (String s : sets2) {
            System.out.println(s);
        }

        //取差集[第一个集合中存在,但是在第二个集合中不存在的元素]
        Set<String> sets3 = operations.difference("names2", "names1");
        for (String s : sets3) {
            System.out.println(s);
        }
    }
}

1.6.5 ZSet 类型

/**
 * ZSet类型
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-redis.xml")
public class RedisZSetTest {

    ZSetOperations<String, String> operations = null;
    @Autowired
    private RedisTemplate redisTemplate;

    @Before
    public void init() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        operations = redisTemplate.opsForZSet();
    }

    /**
     * 增加
     */
    @Test
    public void testAdd() {
        operations.add("students", "zhangsan", 100);
        operations.add("students", "lisi", 60);
        operations.add("students", "wangwu", 80);
    }

    /**
     * 分数的增减
     */
    @Test
    public void testScore() {
        //incrementScore 可以用来增减分数  增加就用正数    减少用负数
        //增加分数
        operations.incrementScore("students", "wangwu", 30);
        //减少分数
        operations.incrementScore("students", "wangwu", -70);
    }

    /**
     * 查询一个元素的信息
     */
    @Test
    public void testFindOne() {
        //查询一个元素的分数
        Double score = operations.score("students", "wangwu");
        System.out.println(score);

        //查询一个元素在集合中的排名   排名从0开始
        Long rank = operations.rank("students", "zhangsan");
        System.out.println(rank);
    }

    /**
     * 根据一个区间获得一个列表
     */
    @Test
    public void testFindList() {
        //根据排名区间来获取元素列表
        Set<String> students = operations.range("students", 0, 2);
        for (String student : students) {
            System.out.println(student);
        }
        System.out.println("=============");
        Set<ZSetOperations.TypedTuple<String>> set = operations.rangeWithScores("students", 0, 2);
        for (ZSetOperations.TypedTuple<String> tuple : set) {
            System.out.println(tuple.getValue() + "同学,得了" + tuple.getScore() + "分");
        }
        System.out.println("---------------------------------");


        //根据分数区间来获取列表
        Set<String> students2 = operations.rangeByScore("students", 60, 90);
        for (String student : students2) {
            System.out.println(student);
        }
        System.out.println("=============");
        Set<ZSetOperations.TypedTuple<String>> set2 = operations.rangeByScoreWithScores("students", 60, 90);
        for (ZSetOperations.TypedTuple<String> tuple : set2) {
            System.out.println(tuple.getValue() + "同学,得了" + tuple.getScore() + "分");
        }
    }

    /**
     * 统计
     */
    @Test
    public void testCount() {
        //统计一个集合中元素
        Long zCard = operations.zCard("students");
        System.out.println(zCard);

        //根据一个分数区间统计元素数量
        Long count = operations.count("students", 50, 100);
        System.out.println(count);
    }

    /**
     * 删除
     */
    @Test
    public void testRemove() {
        //根据key-value删除  value允许传入多个
        operations.remove("students", "zhangsan", "lisi");

        //根据排名区间删除
        operations.removeRange("students", 0, 1);

        //根据分数区间删除
        operations.removeRangeByScore("students", 70, 100);
    }
}

2. Repository和Template的选用

经过前面的章节，我们学习了SpringData家族中jpa和redis的使用，在感受到SpringData技术使用方便的同时，也隐隐约约感觉有点问题，那就是jpa和redis的使用思路好像不是很一致。

我们使用SpringDataJpa的时候，采用了继承SpringData提供的一个接口的形式，即 public interface ArticleDao extends JpaRepository<Article,Integer>,JpaSpecificationExecutor<Article> ，但是使用SpingData Redis的时候，却是使用了在实现类中注入一个 redisTemplate 的方式，那么这两种方式到底有什么关系，用哪个更好呢？

其实这两种方式都可以完成我们对持久层的操作，但是对比两种方式的使用，就会发现：

第一种方式，直接继承xxxRepository接口，可以不必自己去写实现类，而轻松实现简单的增删改查、分页、排序操作，但是对于非常复杂的查询，用起来就比较的费力了；

第二种方式，直接使用xxxTemplate，就需要自己写实现类，但是这样增删改查可以自己控制，对于复杂查询来说，用起来更加得心应手。

所以，两种方式在企业开发中都可能用到，甚至有的项目开发中会同时使用两种方式:对于简单的操作，直接继承Repository接口，对于复杂操作，使用Template完成。所以我们用的时候也要根据实际场景进行灵活选用。

3. SpringData ElasticSearch

3.1 SpringData ElasticSearch 简介

Elasticsearch是一个实时的分布式搜索和分析引擎。它底层封装了Lucene框架,可以提供分布式多用户的全文搜索服务。

Spring Data ElasticSearch是SpringData技术对ElasticSearch原生API封装之后的产物,它通过对原生API的封装,使得程序员可以简单的对ElasticSearch进行各种操作。

3.2 ElasticSearch 环境搭建

3.2.1 安装ElasticSearch

3.2.1.1 准备工作

修改进程限制,编辑/etc/security/limits.conf,添加下面的代码

* soft nofile 65536
* hard nofile 131072
* soft nproc 2048
* hard nproc 4096

修改系统变量的最大值,编辑/etc/sysctl.conf,添加下面的配置

1	vm.max_map_count = 655360

保存修改之后 ,执行 sysctl -p 命令

sysctl -p

3.2.1.2 文件上传

上传文件到src目录下

3.2.1.3 文件解压

直接将软件解压到安装目录

1	tar -zxvf elasticsearch-5.6.8.tar.gz -C /usr/local

3.2.1.4 添加用户

新增加一个es用户,并将elasticsearch-5.6.8目录的所属用户和用户组改成es

1
2
3

useradd es

chown es:es -R ../elasticsearch-5.6.8

切换到新创建的 es用户,执行后续操作

3.2.1.5 修改配置

编辑配置文件,修改数据文件和日志文件的存储位置以及es的绑定地址

1
2
3

cd /usr/local/elasticsearch-5.6.8/config/

vim elasticsearch.yml

3.2.1.6 启动 elasticSearch

1
2
3

cd /usr/local/elasticsearch-5.6.8/bin/

./elasticsearch

3.2.1.7 访问测试

通过服务器的9200端口访问,得到下面的结果,证明安装成功.

3.2.2 安装 Head插件

3.2.2.1 安装nodeJS

将nodeJS的安装包上传到/usr/local/src下,然后解压到/usr/local下,然后将npm和node建立软连接到/usr/local/bin/下

tar -zxvf node-v10.16.0-linux-x64.tar.gz -C /usr/local/

ln -s /usr/local/node-v10.16.0-linux-x64/bin/npm /usr/local/bin/

ln -s /usr/local/node-v10.16.0-linux-x64/bin/node /usr/local/bin/

node -v

3.2.2.2 安装 cnpm

npm install -g cnpm --registry=https://registry.npm.taobao.org

ln -s /usr/local/node-v10.16.0-linux-x64/bin/cnpm /usr/local/bin/

cnpm -v

3.2.2.3 安装 grunt

1
2
3

npm install -g grunt-cli

ln -s /usr/local/node-v10.16.0-linux-x64/bin/grunt /usr/local/bin

3.2.2.4 安装 head插件

上传head插件到/usr/local/src/下,然后解压到/usr/local下

1
2
3

unzip elasticsearch-head-master.zip

cp -R elasticsearch-head-master /usr/local/

3.2.2.5 安装 head插件所需依赖

1
2
3

cd /usr/local/elasticsearch-head-master

cnpm install

3.2.2.6 修改 elasticsearch的配置

编辑配置文件:/usr/local/elasticsearch-5.6.8/config/elasticsearch.yml,添加跨域请求允许,即增加以下两行：

1 2	http.cors.enabled: true http.cors.allow-origin: "*"

修改完毕之后 ,要对elasticsearch进行重启

3.2.2.7 启动head

在head目录下启动插件

1	grunt server

3.2.2.8 访问测试

通过服务器的9100端口访问,得到下面的结果,证明安装成功.

3.2.3 安装 IK分词器

3.2.3.1 说明

ES默认的中文分词器是将每一个汉字作为一个词，这显然不合适，而IK分词是一款国人开发的相对简单的中文分词器，它包含大量的中文词，而且支持自定义分词。

ik分词器提供的分词规则：

ik_max_word ：会将文本做最细粒度的拆分，比如会将“中华人民共和国人民大会堂”拆分为“中华人民共和国、中华人民、中华、华人、人民共和国、人民、共和国、大会堂、大会、会堂等词语。
ik_smart ：会做最粗粒度的拆分，比如会将“中华人民共和国人民大会堂”拆分为中华人民共和国、人民大会堂

两种分词器使用的最佳实践是：索引时用ik_max_word，在搜索时用ik_smart。即：索引时最大化的将文章内容分词，搜索时更精确的搜索到想要的结果。

3.2.3.2 安装

第一步:下载得到ik分词器的安装包,将其解压得到有一个文件夹,并将文件夹重命名为ik

1	unzip elasticsearch-analysis-ik-5.6.8.zip

第二步 :将elastaicsearch文件夹拷贝到elastaicsearch-5.6.8下的plugins目录下,并重命名为ik

1	cp -r elasticsearch /usr/local/elasticsearch-5.6.8/plugins/ik

第三步 :重新启动elasticsearch即可加载IK分词器

第四部:测试

http://服务地址:9200/_analyze?analyzer=ik_smart&pretty=true&text=我是程序员

3.3 ElasticSearch 基础知识回顾

3.3.1 核心概念

3.3.1.1 索引 index

一个索引就是一个拥有几分相似特征的文档的集合。索引就类似于关系型数据库中的库的概念。

3.3.1.2 类型 type

一个类型是索引中的一个逻辑上的分类/分区。类型就类似于关系型数据库中的数据表的概念。

3.3.1.3 映射 mapping

映射是对类型中的字段的限制。映射就类似于关系型数据库中的数据表结构的概念。

3.3.1.4 文档 document

一个文档是一个可被索引的基础信息单元。文档就类似于关系型数据库中的行的概念。

1
2
3

ElasticSearch跟关系型数据库中概念的对比：
Relational DB -> Databases -> Tables -> Rows -> Columns
Elasticsearch -> Indices -> Types -> Documents -> Fields

3.3.2 常见操作

3.3.2.1 创建工程，引入坐标

<dependencies>
    <!--elasticsearch-->
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>6.5.4</version>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>transport</artifactId>
        <version>6.5.4</version>
    </dependency>

    <!--单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!--日志-->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-to-slf4j</artifactId>
        <version>2.9.1</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.24</version>
    </dependency>
</dependencies>

3.3.2.2 操作测试

/**
 * es测试
 *
 * @author wgy
 */
public class EsTest {

    TransportClient client = null;

    /**
     * 创建连接
     */
    @Before
    public void initClient() {
        try {
            //设置集群名称
            Settings settings = Settings.builder().put("cluster.name", "wgy-es").build();// 集群名
            client = new PreBuiltTransportClient(settings)
                    .addTransportAddress(
                            new TransportAddress(
                                    InetAddress.getByName("192.168.142.128"), 9700
                            )
                    );
        } catch (UnknownHostException e) {
            System.out.println("初始化失败....");
            e.printStackTrace();
        }
    }

    /**
     * 关闭连接
     */
    @After
    public void closeClient() {
        client.close();
    }

    /**
     * 创建索引
     *
     * @throws UnknownHostException
     */
    @Test
    public void testCreateIndex() throws UnknownHostException {
        client.admin().indices().prepareCreate("test").get();
    }

    /**
     * 删除索引,可以一次性删除多个
     *
     * @throws UnknownHostException
     */
    @Test
    public void testDeleteIndex() throws UnknownHostException {
        client.admin().indices().prepareDelete("test", "springData").get();
    }
    
    /**
     * 创建映射
     *
     * @throws Exception
     */
    @Test
    public void testCreateMappping() throws Exception {
        XContentBuilder builder = XContentFactory.jsonBuilder()
                .startObject()
                .startObject("article")
                .startObject("properties")

                .startObject("title")
                .field("type", "text")
                .field("store", "true")
                .field("analyzer", "ik_smart")
                .endObject()

                .startObject("content")
                .field("type", "text")
                .field("store", "true")
                .field("analyzer", "ik_smart")
                .endObject()

                .startObject("hits")
                .field("type", "long")
                .field("store", "true")
                .endObject()

                .endObject()
                .endObject()
                .endObject();

        // 创建映射(表结构)
        PutMappingRequest mapping = Requests.putMappingRequest("test")//指定索引(库)
                .type("article")//指定类型(表)
                .source(builder);
        client.admin().indices().putMapping(mapping).get();
    }

    /**
     * 创建文档
     */
    @Test
    public void testCreateDocuments() {

        //组装数据
        Map<String, Object> map = new HashMap<>();
        map.put("title", "程序员");
        map.put("content", "程序员其实很低调");
        map.put("hits", 100);

        //创建文档
        client.prepareIndex("test", "article", "1").setSource(map).get();
    }

    /**
     * 修改文档
     */
    @Test
    public void testUpdateDocuments() {

        //组装数据
        Map<String, Object> map = new HashMap<>();
        map.put("title", "程序员2");
        map.put("content", "程序员很低调2");
        map.put("hits", 200);

        //修改文档
        client.prepareUpdate("test", "article", "1").setDoc(map).get();
    }

    /**
     * 删除文档
     */
    @Test
    public void testDeleteDocuments() {
        client.prepareDelete("test", "article", "1").get();
    }

    /**
     * 查询所有
     */
    @Test
    public void testFindAll() {

        //1 设置index type  查询条件,返回一个查询结果对象
        SearchResponse searchResponse = client.prepareSearch("test").setTypes("article")//设置index和type,允许传入多个
                .setQuery(QueryBuilders.matchAllQuery())//设置查询条件 :查询所有
                .get();

        //2 检索的命中对象
        SearchHits hits = searchResponse.getHits();

        //3 获取查询结果数
        System.out.println("总共查询到" + hits.getTotalHits() + "条记录");

        //4 获取结果
        Iterator<SearchHit> iterator = hits.iterator();
        while (iterator.hasNext()) {
            SearchHit searchHit = iterator.next();
            System.out.println(searchHit.getSourceAsString());
        }
    }

    /**
     * 根据title查询
     */
    @Test
    public void testFindByTitle() {

        //QueryBuilders.termQuery("属性","值[分词之后存在]")
        //1 设置index type  查询条件,返回一个查询结果对象
        SearchResponse searchResponse = client.prepareSearch("test").setTypes("article")//设置index和type,允许传入多个
                .setQuery(QueryBuilders.termQuery("title", "员"))//设置查询条件 :根据title查询
                .get();

        //2 检索的命中对象
        SearchHits hits = searchResponse.getHits();

        //3 获取查询结果数
        System.out.println("总共查询到" + hits.getTotalHits() + "条记录");

        //4 获取结果
        Iterator<SearchHit> iterator = hits.iterator();
        while (iterator.hasNext()) {
            SearchHit searchHit = iterator.next();
            System.out.println(searchHit.getSourceAsString());
        }
    }

    /**
     * 分页和排序
     */
    @Test
    public void testFindAllWithPageAndSort() {

        //1 设置index type  查询条件,返回一个查询结果对象
        SearchResponse searchResponse = client.prepareSearch("test").setTypes("article")//设置index和type,允许传入多个
                .setQuery(QueryBuilders.matchAllQuery())//设置查询条件 :查询所有
                .setFrom(0).setSize(20)//设置分页的条件 .setFrom(从第几行开始查).setSize(查多少行)
                .addSort("hits", SortOrder.ASC)//设置分页条件 .addSort(属性, 排序规则)
                .get();

        //2 检索的命中对象
        SearchHits hits = searchResponse.getHits();//20

        //3 获取查询结果数
        System.out.println("总共查询到" + hits.getTotalHits() + "条记录");

        //4 获取结果
        Iterator<SearchHit> iterator = hits.iterator();
        while (iterator.hasNext()) {
            SearchHit searchHit = iterator.next();
            System.out.println(searchHit.getSourceAsString());
        }
    }
}

3.4 SpringData ElasticSearch 入门案例

3.4.1 目标

通过SpringData ES技术向ElasticSearch数据库存储一条数据

3.4.2 创建工程，引入坐标

<dependencies>
    <!--elasticsearch-->
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>6.2.2</version>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>transport</artifactId>
        <version>6.2.2</version>
    </dependency>

    <!--spring-data-elasticsearch-->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-elasticsearch</artifactId>
        <version>3.1.20.RELEASE</version>
    </dependency>

    <!--日志-->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-to-slf4j</artifactId>
        <version>2.9.1</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.24</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>

    <!--单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>
</dependencies>

3.4.3 添加配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
       xsi:schemaLocation="http://www.springframework.org/schema/data/elasticsearch
        http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 扫描dao包 -->
    <elasticsearch:repositories base-package="com.wgy"/>

    <!-- 配置Client -->
    <elasticsearch:transport-client id="client" cluster-nodes="192.168.142.128:9700" cluster-name="wgy-es"/>

    <!-- 配置搜索模板 -->
    <bean id="elasticsearchTemplate" class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
        <constructor-arg name="client" ref="client"/>
    </bean>
</beans>

3.4.4 创建实体类

/**
 * 文章实体类
 *
 * @author wgy
 */
//indexName指定索引名称   type  指定类型名称
@Document(indexName = "test-sd", type = "article")
public class Article {

    @Id
    @Field(index = false, type = FieldType.Integer)
    private Integer id;
    /**
     * index：是否设置分词  默认是true
     * analyzer：存储时使用的分词器
     * searchAnalyze：搜索时使用的分词器
     * store：是否存储 默认是false
     * type: 数据类型 默认值是FieldType.Auto
     */
    @Field(analyzer = "ik_smart", searchAnalyzer = "ik_smart", store = true, type = FieldType.Text)
    private String title;
    @Field(analyzer = "ik_smart", searchAnalyzer = "ik_smart", store = true, type = FieldType.Text)
    private String context;
    @Field(store = true, type = FieldType.Integer)
    private Integer hits;
    
    //省略set和get方法。。。
    //省略toString方法。。
}

3.4.5 自定义 dao接口

/**
 * dao接口
 * 自定义的接口需要继承ElasticsearchRepository<实体类型,主键类型>  基本的crud 分页
 *
 * @author wgy
 */
public interface ArticleDao extends ElasticsearchRepository<Article, Integer> {
}

3.4.6 测试

/**
 * SpringData ElasticSearch 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-es.xml")
public class EsTest {

    @Autowired
    private ElasticsearchTemplate template;

    @Autowired
    private ArticleDao articleDao;

    //通过SpringData ES技术向ElasticSearch数据库存储一条数据
    @Test
    public void testSave() {
        //创建索引
        template.createIndex(Article.class);

        //创建映射
        template.putMapping(Article.class);

        //创建文档
        Article article = new Article();
        article.setId(1);
        article.setTitle("sd-程序员");
        article.setContext("sd-程序员很棒");

        //保存文档
        articleDao.save(article);
    }
}

3.5 SpringData ElasticSearch 实现CRUD操作

3.5.1 增删改

/**
 * SpringData ElasticSearch 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-es.xml")
public class EsTest {

    @Autowired
    private ElasticsearchTemplate template;

    @Autowired
    private ArticleDao articleDao;

    //通过SpringData ES技术向ElasticSearch数据库存储一条数据
    @Test
    public void testSave() {
        //创建索引
        template.createIndex(Article.class);

        //创建映射
        template.putMapping(Article.class);

        //创建文档
        Article article = new Article();
        article.setId(1);
        article.setTitle("sd-程序员");
        article.setContext("sd-程序员很棒");

        //保存文档
        articleDao.save(article);
    }

    /**
     * 修改
     */
    @Test
    public void testUpdate() {

        //判断数据库中是否有你指定的id的文档,如果没有,就进行保存,如果有,就进行更新
        Article article = new Article();
        article.setId(1);
        article.setTitle("sd-程序员1");
        article.setContext("sd-程序员很棒1");

        articleDao.save(article);
    }

    /**
     * 删除
     */
    @Test
    public void testDelete() {
        //根据主键删除
        articleDao.deleteById(1);
    }
}

3.5.2 接口方法查询

/**
 * SpringData ElasticSearch 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-es.xml")
public class EsTest {

    @Autowired
    private ElasticsearchTemplate template;

    @Autowired
    private ArticleDao articleDao;

    /**
     * 查询所有
     */
    @Test
    public void testFindAll() {
        Iterable<Article> all = articleDao.findAll();
        for (Article article : all) {
            System.out.println(article);
        }
    }

    /**
     * 主键查询
     */
    @Test
    public void testFindById() {
        Optional<Article> opt = articleDao.findById(1);
        System.out.println(opt.get());
    }

    /**
     * 分页查询
     */
    @Test
    public void testFindAllWithPage() {
        //设置分页条件
        Pageable pageable = PageRequest.of(1, 3);//page代表的页码,从0开始

        Page<Article> page = articleDao.findAll(pageable);

        for (Article article : page.getContent()) {
            System.out.println(article);
        }
    }

    /**
     * 排序查询
     */
    @Test
    public void testFindAllWithSort() {
        //设置排序条件
        Sort sort = Sort.by(Sort.Order.desc("hits"));

        Iterable<Article> all = articleDao.findAll(sort);
        for (Article article : all) {
            System.out.println(article);
        }
    }

    /**
     * 分页+排序查询
     */
    @Test
    public void testFindAllWithPageAndSort() {
        //设置排序条件
        Sort sort = Sort.by(Sort.Order.desc("hits"));

        //设置分页条件
        Pageable pageable = PageRequest.of(1, 3, sort);//page代表的页码,从0开始

        Page<Article> page = articleDao.findAll(pageable);

        for (Article article : page.getContent()) {
            System.out.println(article);
        }
    }
}

3.5.3 命名规则查询

es的命名规则跟jpa基本一致，常见的如下：

关键字	命名规则	解释	示例
and	findByField1AndField2	根据Field1和Field2获得数据	findByTitleAndContent
or	findByField1OrField2	根据Field1或Field2获得数据	findByTitleOrContent
is	findByField	根据Field获得数据	findByTitle
not	findByFieldNot	根据Field获得补集数据	findByTitleNot
between	findByFieldBetween	获得指定范围的数据	findByPriceBetween
lessThanEqual	findByFieldLessThan	获得小于等于指定值的数据	findBy

下面,我们在dao接口中按照规则进行自定义查询方法

/**
 * dao接口
 * 自定义的接口需要继承ElasticsearchRepository<实体类型,主键类型>  基本的crud 分页
 *
 * @author wgy
 */
public interface ArticleDao extends ElasticsearchRepository<Article, Integer> {

    /**
     * 根据标题查询
     *
     * @param title
     * @return
     */
    List<Article> findByTitle(String title);

    /**
     * 根据标题或内容查询
     *
     * @param title
     * @param context
     * @return
     */
    List<Article> findByTitleOrContext(String title, String context);

    /**
     * 根据标题或内容查询(含分页)
     *
     * @param title
     * @param context
     * @param pageable
     * @return
     */
    List<Article> findByTitleOrContext(String title, String context, Pageable pageable);

}

添加测试方法

/**
 * SpringData ElasticSearch 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-es.xml")
public class EsTest {

    @Autowired
    private ArticleDao articleDao;

    /**
     * 根据标题查询
     */
    @Test
    public void testFindByTitle() {
        List<Article> articles = articleDao.findByTitle("员");
        for (Article article : articles) {
            System.out.println(article);
        }
    }

    /**
     * 根据标题或内容查询
     */
    @Test
    public void testFindByTitleOrContext() {
        List<Article> articles = articleDao.findByTitleOrContext("程序员", "程序员");
        for (Article article : articles) {
            System.out.println(article);
        }
    }

    /**
     * 根据标题或内容查询(含分页)
     */
    @Test
    public void testFindByTitleOrContextWithPage() {

        //设置排序条件
        Sort sort = Sort.by(Sort.Order.desc("hits"));

        //设置分页条件
        Pageable pageable = PageRequest.of(1, 3, sort);//page代表的页码,从0开始

        List<Article> articles = articleDao.findByTitleOrContext("程序员", "程序员", pageable);
        for (Article article : articles) {
            System.out.println(article);
        }
    }
}

4. SpringData MongoDB

4.1 SpringData MongoDB 简介

MongoDB 是一个跨平台的，面向文档的数据库，是非关系数据库当中功能最丰富，最像关系数据库的产品。它支持的数据结构非常松散，是类似 JSON 的一种格式，因此可以存储比较复杂的数据类型。

MongoDB主要由文档(document)、集合(collection)、数据库(database)三部分组成

文档（ document）就相当于关系数据库中的一行记录
多个文档组成一个集合（ collection），相当于关系数据库的表
多个集合组织在一起，就是数据库（ database），一个 MongoDB 实例支持多个数据库

SpringData MongoDB是SpringData技术封装了mongodb-driver技术之后的产物,它可以用更加简单的方式操作MongoDB。

4.2 MongoDB 环境搭建

4.2.1 解压

上传文件到服务器，然后将其解压到/usr/local下

1	tar -zxvf mongodb-linux-x86_64-rhel70-4.0.10.tgz -C /usr/local/

4.2.2 创建需要的目录

进入软件的安装目录下,创建数据存储和日志存储目录

cd /usr/local/mongodb-linux-x86_64-rhel70-4.0.10/

mkdir data
touch log

4.2.3 创建配置文件

进入bin目录,创建mongodb的配置文件mongo.conf ,文件内容如下:

dbpath=/usr/local/mongodb-linux-x86_64-rhel70-4.0.10/data
logpath=/usr/local/mongodb-linux-x86_64-rhel70-4.0.10/log
bind_ip=0.0.0.0
port=27017
fork=true

4.2.4 启动 mongodb

使用./mongod -f mongo.conf 启动服务,见到类似如下提示,证明启动成功

1	./mongod -f mongo.conf

4.3 SpringData MongoDB 入门案例

4.3.1 目标

通过SpringData技术向Mongodb数据库存储一条数据

4.3.2 创建工程，引入坐标

<dependencies>
    <!--spring-data-mongodb-->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-mongodb</artifactId>
        <version>2.2.10.RELEASE</version>
    </dependency>
    <!--测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>
</dependencies>

4.3.3 创建配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/data/mongo
        http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">

    <!--包扫描-->
    <mongo:repositories base-package="com.wgy"/>


    <!-- spring连接mongodb数据库的配置 -->
    <!--
        host="192.168.142.128" 指定mongodb服务所在主机地址
        port="27017"  指定mongodb服务所在主机端口号
        dbname="springdata"  数据名称
    -->
    <mongo:mongo-client host="192.168.142.128" port="27017" id="mongo" credentials="bobo:123456@springdata">
        <mongo:client-options write-concern="SAFE"/>
    </mongo:mongo-client>

    <mongo:db-factory id="mongoDbFactory" dbname="springdata" mongo-ref="mongo"/>

    <!--mongoTemplate-->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
    </bean>
</beans>

4.3.4 创建实体类

/**
 * 文章实体类
 *
 * @author wgy
 */
//使用@Document建立的是实体类和collection的关系
@Document("article")
public class Article {

    @Id//用来标识主键
    private Integer id;

    //使用@Field建立实体类中属性跟collection中字段的映射关系,如果省略,代表两个名称一致
    //@Field
    private String name;
    private String content;
    private Integer hits;
    
    //省略set和get方法。。。
    //省略toString方法。。
}

4.3.5 自定义 dao接口

/**
 * dao接口
 *
 * @author wgy
 */
public interface ArticleDao extends MongoRepository<Article, Integer> {
}

4.3.6 测试

/**
 * SpringData MongoDB 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ArticleDaoTest {

    @Autowired
    private ArticleDao articleDao;

    /**
     * 保存
     */
    @Test
    public void testSave() {
        Article article = new Article();
        article.setId(1);
        article.setName("程序员");
        article.setContent("程序员很低调");
        article.setHits(100);

        articleDao.save(article);
    }
}

4.4 SpringData MongoDB 实现CRUD操作

4.4.1 增删改

/**
 * SpringData MongoDB 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ArticleDaoTest {

    @Autowired
    private ArticleDao articleDao;

    /**
     * 保存
     */
    @Test
    public void testSave() {
        Article article = new Article();
        article.setId(1);
        article.setName("程序员");
        article.setContent("程序员很低调");
        article.setHits(100);

        articleDao.save(article);
    }

    /**
     * 修改
     */
    @Test
    public void testUpdate() {
        Article article = new Article();
        article.setId(1);
        article.setName("程序员2");
        article.setContent("程序员很低调2");
        article.setHits(200);

        articleDao.save(article);
    }

    /**
     * 删除
     */
    @Test
    public void testDelete() {
        articleDao.deleteById(1);
    }
}

4.4.2 简单查询

/**
 * SpringData MongoDB 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ArticleDaoTest {

    @Autowired
    private ArticleDao articleDao;

    /**
     * 查询所有
     */
    @Test
    public void testFindAll() {
        List<Article> articles = articleDao.findAll();
        for (Article article : articles) {
            System.out.println(article);
        }
    }

    /**
     * 主键查询
     */
    @Test
    public void testFindById() {
        Optional<Article> opt = articleDao.findById(1);
        System.out.println(opt.get());
    }

    /**
     * 分页和排序
     */
    @Test
    public void testFindAllWithPageAndSort() {

        //设置排序条件
        Sort sort = Sort.by(Sort.Order.desc("hits"));

        //设置分页条件
        Pageable pageable = PageRequest.of(1, 3, sort);

        Page<Article> page = articleDao.findAll(pageable);
        for (Article article : page.getContent()) {
            System.out.println(article);
        }
    }
}

4.4.3 命名规则查询

定义接口

/**
 * dao接口
 *
 * @author wgy
 */
public interface ArticleDao extends MongoRepository<Article, Integer> {

    /**
     * 根据标题查询
     *
     * @param name
     * @return
     */
    List<Article> findByNameLike(String name);

    /**
     * 根据点击量查询
     *
     * @param hits
     * @return
     */
    List<Article> findByHitsGreaterThan(Integer hits);
}

测试方法

/**
 * SpringData MongoDB 入门案例
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ArticleDaoTest {

    @Autowired
    private ArticleDao articleDao;
    
    /**
     * 根据标题查询
     */
    @Test
    public void testFindByName() {
        List<Article> articles = articleDao.findByNameLike("程序员1");
        for (Article article : articles) {
            System.out.println(article);
        }
    }

    /**
     * 根据点击量查询
     */
    @Test
    public void testFindByHitsGreaterThan() {
        List<Article> articles = articleDao.findByHitsGreaterThan(105);
        for (Article article : articles) {
            System.out.println(article);
        }
    }
}

5. 综合案例

5.1 案例说明及思路分析

5.1.1 案例目标

通过一个【文章】案例来综合使用SpringData技术，案例中将涉及到jpa、redis、es、mongo的使用，可以很好的将前面章节所学知识点加以练习巩固。

5.1.2 涉及技术分析

案例以常见网站中的文章管理和查询为背景，涉及到文章内容、最新文章列表、文章评论、文章检索等功能，下面具体分析：

文章内容分为文章基础和文章详情两部分，分别存储在 mysql的文章表和文章详情表中
最新文章列表展示的是热点数据，访问量比较大，采用 redis存储
文章评论数据量大，数据价值较低，存放在 mongodb中
全文检索使用 ES实现，本次直接向ES中插入测试数据测试，后期可以考虑使用logstash从数据库同步

5.1.3 功能分析

5.1.3.1 数据后台管理

功能	mysql	redis	mongodb	ES
添加文章	添加数据	清空缓存		添加数据
修改文章	修改数据	清空缓存		修改数据
删除文章	删除数据	清空缓存	删除文章评论	删除数据
添加评论			添加文章评论
删除评论			删除文章评论

5.1.3.2 数据查询功能

功能	mysql	redis	mongodb	ES
查询最新文章	当redis中不存在时来数据库查	先从redis查，没有再去数据库查，查到以后放入redis
查询文章评论			根据文章标识从mongo中获取评论数据
文章检索				使用es实现文章检索功能

5.2 代码实现

5.2.1 项目结构说明

本次案例采用Spring为核心骨架，使用SpringData实现持久层操作，采用junit进行功能测试，完整项目结构如下图所示

5.2.2 创建工程，引入坐标

<dependencies>
    <!-- 日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <!-- 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!-- Spring框架相关jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

    <!--mvc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.4</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
    </dependency>

    <!--jpa-->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>2.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>5.0.7.Final</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <!--redis-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.3</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>2.1.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.8</version>
    </dependency>

    <!--es-->
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>6.2.2</version>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>transport</artifactId>
        <version>6.2.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-elasticsearch</artifactId>
        <version>3.1.20.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-to-slf4j</artifactId>
        <version>2.9.1</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.24</version>
    </dependency>

    <!--mongo-->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-mongodb</artifactId>
        <version>2.2.0.RELEASE</version>
    </dependency>

    <!--工具-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.1</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.55</version>
    </dependency>
</dependencies>

5.2.3 加入配置文件

5.2.3.1 jpa 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!-- 配置要扫描的包 -->
    <context:component-scan base-package="com.wgy"/>

    <!-- 1.dataSource -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///case"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!-- 2.EntityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 指定实体类所在的包 -->
        <property name="packagesToScan" value="com.wgy.domain"/>
        <!-- 指定jpa的实现提供者 -->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--JPA供应商适配器 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!-- 是否生成DDL语句   是否自动建表 -->
                <property name="generateDdl" value="true"/>
                <!-- 数据库厂商名称 -->
                <property name="database" value="MYSQL"/>
                <!-- 数据库方言 -->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <!-- 是否显示SQL -->
                <property name="showSql" value="true"/>
            </bean>
        </property>
    </bean>

    <!-- 3.事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!-- 整合spring data jpa -->
    <!--spring 通过代理的方式为dao接口提供实现类，需要指明为哪些接口去产生代理类-->
    <jpa:repositories base-package="com.wgy.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"/>

    <!-- 4.txAdvice -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" propagation="SUPPORTS"/>
            <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
        </tx:attributes>
    </tx:advice>

    <!-- 5.aop -->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.wgy.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

5.2.3.2 redis 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- redis 相关配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--最大空闲数-->
        <property name="maxIdle" value="300"/>
        <!--连接时的最大等待毫秒数-->
        <property name="maxWaitMillis" value="3000"/>
        <!--在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的-->
        <property name="testOnBorrow" value="false"/>
    </bean>

    <!--连接工厂-->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:host-name="192.168.142.128" p:port="6379" p:pool-config-ref="poolConfig" p:password="123456">
    </bean>

    <!--redisTemplate-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
        <!--指定数据序列化器-->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
    </bean>
</beans>

5.2.3.3 es 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
       xsi:schemaLocation="http://www.springframework.org/schema/data/elasticsearch
       http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 扫描dao包 -->
    <elasticsearch:repositories base-package="com.wgy.es"/>

    <!-- 配置Client -->
    <elasticsearch:transport-client id="client" cluster-nodes="192.168.142.128:9700" cluster-name="wgy-es"/>

    <!-- 配置搜索模板  -->
    <bean id="elasticsearchTemplate" class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
        <constructor-arg name="client" ref="client"/>
    </bean>
</beans>

5.2.3.4 mongo 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
               http://www.springframework.org/schema/data/mongo
            http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">

    <!--包扫描-->
    <mongo:repositories base-package="com.wgy.mongo"/>

    <!-- spring连接mongodb数据库的配置 -->
    <mongo:mongo-client host="192.168.142.128" port="27017" id="mongo" credentials="bobo:123456@case">
        <mongo:client-options write-concern="SAFE"/>
    </mongo:mongo-client>

    <mongo:db-factory id="mongoDbFactory" dbname="case" mongo-ref="mongo"/>

    <!--mongoTemplate-->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
    </bean>
</beans>

5.2.3.5 汇总配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--汇总其它配置文件-->
    <import resource="applicationContext-jpa.xml"/>
    <import resource="applicationContext-redis.xml"/>
    <import resource="applicationContext-es.xml"/>
    <import resource="applicationContext-mongo.xml"/>
</beans>

5.2.4 创建实体类

5.2.4.1 Article（对应数据库文章表）

/**
 * 文章实体类
 *
 * @author wgy
 */
@Entity
@Table(name = "article")
public class Article implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer aid;//主键
    private String title;//文章标题
    private String author;//文章作者
    private Date createTime;//创建时间

    //建立从Article到ArticleData的一对一关系
    @OneToOne(mappedBy = "article")
    private ArticleData articleData;
    
    //省略set和get方法。。。
    //省略toString方法。。
}

5.2.4.2 ArticleData （对应数据库文章表）

/**
 * 文章详情实体类
 *
 * @author wgy
 */
@Entity
@Table(name = "article_data")
public class ArticleData implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;//主键
    private String content;//文章内容

    //建立从ArticleData到Article的一对一关系
    @OneToOne
    //@JoinColumn(name=当前表的外键字段名称,referencedColumnName 指向对方表的主键)
    @JoinColumn(name = "articleId", referencedColumnName = "aid", unique = true)
    private Article article;
    
    //省略set和get方法。。。
    //省略toString方法。。
}

5.2.4.3 EsArticle ( 对应ES中的文章)

/**
 * es文章实体类
 *
 * @author wgy
 */
@Document(indexName = "case", type = "article")
public class EsArticle implements Serializable {

    @Id
    @Field(type = FieldType.Integer)
    private Integer id;//主键标识

    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_smart", store = true)
    private String title;//标题

    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_smart", store = true)
    private String content;//内容

    @Field(type = FieldType.Text)
    private String author;//作者

    @Field(type = FieldType.Date)
    private Date createTime;//创建时间
    
    //省略set和get方法。。。
    //省略toString方法。。
}

5.2.4.4 Comment ( 对应mongodb中的评论)

/**
 * 文章评论实体类
 *
 * @author wgy
 */
@Document(collection = "comment")
public class Comment implements Serializable {

    @Id
    private String cid;//主键
    private Integer aid;//文章标识
    private String comment;//评论
    private String nickname;//评论者昵称
    
    //省略set和get方法。。。
    //省略toString方法。。
}

5.2.5 创建 dao层接口

5.2.5.1 ArticleDao

/**
 * 文章dao接口
 *
 * @author wgy
 */
public interface ArticleDao extends JpaRepository<Article, Integer> {
}

5.2.5.2 ArticleDataDao

/**
 * 文章详情dao接口
 *
 * @author wgy
 */
public interface ArticleDataDao extends JpaRepository<ArticleData, Integer> {

    /**
     * 根据aid修改ArticleData中的content
     * Jpa规定如果想使用JPQL进行更新或者删除操作,必须要使用@Modifying显示声明
     *
     * @param content
     * @param aid
     */
    @Modifying
    @Query("update ArticleData ad set ad.content = ?1 where ad.article.aid = ?2")
    void updateContentByAid(String content, Integer aid);

    /**
     * 根据aid删除ArticleData中的文章详情
     *
     * @param aid
     */
    @Modifying
    @Query("delete from ArticleData ad where ad.article.aid = ?1")
    void deleteByAid(Integer aid);
}

5.2.5.3 EsArticleDao

/**
 * es文章dao接口
 *
 * @author wgy
 */
public interface EsArticleDao extends ElasticsearchRepository<EsArticle, Integer> {

    /**
     * 根据title或者content进行查询
     *
     * @param title
     * @param content
     * @param pageable
     * @return
     */
    List<EsArticle> findByTitleOrContent(String title, String content, Pageable pageable);
}

5.2.5.4 CommentDao

/**
 * 文章评论dao接口
 *
 * @author wgy
 */
public interface CommentDao extends MongoRepository<Comment, String> {

    /**
     * 命名规则查询:按照aid查询到一个文章的所有评论
     *
     * @param aid
     * @return
     */
    List<Comment> findByAid(Integer aid);
}

5.2.6 创建 service层

5.2.6.1 ArticleService接口

/**
 * 文章业务接口
 *
 * @author wgy
 */
public interface ArticleService {

    /**
     * 保存文章
     *
     * @param article
     */
    void saveArticle(Article article);


    /**
     * 更新文章
     *
     * @param article
     */
    void updateArticle(Article article);


    /**
     * 删除文章
     *
     * @param aid
     */
    void deleteByAid(Integer aid);

    /**
     * 最新文章列表
     *
     * @return
     */
    List<Article> findNewArticleList();

    /**
     * 文章检索
     *
     * @param pageNum
     * @param pageSize
     * @param keyword
     * @return
     */
    List<EsArticle> search(Integer pageNum, Integer pageSize, String keyword);
}

5.2.6.2 ArticleServiceImpl 实现类

/**
 * 文章业务实现类
 *
 * @author wgy
 */
@Service
public class ArticleServiceImpl implements ArticleService {


    @Autowired
    private ArticleDao articleDao;

    @Autowired
    private ArticleDataDao articleDataDao;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Autowired
    private EsArticleDao esArticleDao;

    @Autowired
    private CommentDao commentDao;

    @Override
    public void saveArticle(Article article) {
        // 向mysql保存文章和文章详情
        articleDataDao.save(article.getArticleData());
        articleDao.save(article);

        // 清空redis缓存
        redisTemplate.delete("articles");

        // 向ES中保存数据
        EsArticle esArticle = new EsArticle();
        esArticle.setCreateTime(article.getCreateTime());
        esArticle.setContent(article.getArticleData().getContent());
        esArticle.setTitle(article.getTitle());
        esArticle.setAuthor(article.getAuthor());
        esArticle.setId(article.getAid());
        esArticleDao.save(esArticle);
    }

    @Override
    public void updateArticle(Article article) {
        //更新article
        Article articleParam = new Article();
        articleParam.setTitle(article.getTitle());
        articleParam.setAid(article.getAid());
        articleParam.setAuthor(article.getAuthor());
        articleParam.setCreateTime(article.getCreateTime());
        articleDao.save(articleParam);

        //更新articleData
        articleDataDao.updateContentByAid(article.getArticleData().getContent(), article.getAid());

        //清空redis缓存
        redisTemplate.delete("articles");

        //向ES中保存数据
        EsArticle esArticle = new EsArticle();
        esArticle.setId(article.getAid());
        esArticle.setCreateTime(article.getCreateTime());
        esArticle.setContent(article.getArticleData().getContent());
        esArticle.setTitle(article.getTitle());
        esArticle.setAuthor(article.getAuthor());
        esArticleDao.save(esArticle);
    }

    @Override
    public void deleteByAid(Integer aid) {
        //删除articleData
        articleDataDao.deleteByAid(aid);

        //删除article
        articleDao.deleteById(aid);

        //删除mongodb中相关的评论
        //1---先根据aid查询到一个comment列表
        List<Comment> comments = commentDao.findByAid(aid);

        //2---删除一个评论列表
        commentDao.deleteAll(comments);

        //清空redis
        redisTemplate.delete("articles");

        //删除ES中的数据
        esArticleDao.deleteById(aid);
    }

    @Override
    public List<Article> findNewArticleList() {
        //1 先从redis中获取
        String value = redisTemplate.opsForValue().get("articles");

        //2 如果redis中没有,去数据库中查询,查询到以后,要存入redis
        if (StringUtils.isEmpty(value)) {
            //设置分页排序条件
            Pageable pageable = PageRequest.of(0, 10, Sort.by(Sort.Order.desc("createTime")));
            Page<Article> page = articleDao.findAll(pageable);
            List<Article> content = page.getContent();
            //将结果转成String,存入redis
            if (content != null && content.size() > 0) {
                value = JSONObject.toJSONString(content);
                redisTemplate.opsForValue().set("articles", value);
            }
        }
        //3 将结果转成List返回
        return JSONObject.parseArray(value, Article.class);
    }

    @Override
    public List<EsArticle> search(Integer pageNum, Integer pageSize, String keyword) {
        //设置分页条件
        Pageable pageable = PageRequest.of(pageNum, pageSize);
        return esArticleDao.findByTitleOrContent(keyword, keyword, pageable);
    }
}

5.2.6.3 CommentService 接口

/**
 * 文章评论业务接口
 *
 * @author wgy
 */
public interface CommentService {

    /**
     * 保存
     *
     * @param comment
     */
    void saveComment(Comment comment);

    /**
     * 删除
     *
     * @param cid
     */
    void deleteByCid(String cid);

    /**
     * 根据文章标识查询评论数据
     *
     * @param aid
     * @return
     */
    List<Comment> findCommentsByAid(Integer aid);
}

5.2.6.4 CommentServiceImpl 实现类

/**
 * 文章评论业务实现类
 *
 * @author wgy
 */
@Service
public class CommentServiceImpl implements CommentService {

    @Autowired
    private CommentDao commentDao;

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void saveComment(Comment comment) {
        commentDao.save(comment);
    }

    @Override
    public void deleteByCid(String cid) {
        commentDao.deleteById(cid);
    }

    @Override
    public List<Comment> findCommentsByAid(Integer aid) {
        return commentDao.findByAid(aid);
    }
}

5.2.7 测试

5.2.7.1 后台管理功能测试

/**
 * 测后台管理功能测试
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ManageTest {

    @Autowired
    private ArticleService articleService;

    @Autowired
    private CommentService commentService;

    /**
     * 保存文章
     */
    @Test
    public void testSaveArticle() {

        //准备测试数据
        ArticleData articleData = new ArticleData();
        articleData.setContent("1程序员专注于IT培训,Java培训,人工智能培训,Python培训,大数据培训,区\n" +
                "块链培训,UI设计培训,PHP培训,Web前端培训,软件测试培训,产品经理培训，并提供Java培训,大数据培训,区块链培训,UI\n" +
                "设计培训,PHP培训,软件测试培训,产品经理培训等服务。");

        Article article = new Article();
        article.setTitle("1程序员介绍");
        article.setAuthor("1程序员");
        article.setCreateTime(new Date());

        //建立两者关系
        article.setArticleData(articleData);
        articleData.setArticle(article);

        articleService.saveArticle(article);
    }

    /**
     * 更新文章
     */
    @Test
    public void testUpdateArticle() {

        //准备测试数据
        ArticleData articleData = new ArticleData();
        articleData.setContent("2程序员专注于IT培训,Java培训,人工智能培训,Python培训,大数据培训,区\n" +
                "块链培训,UI设计培训,PHP培训,Web前端培训,软件测试培训,产品经理培训，并提供Java培训,大数据培训,区块链培训,UI\n" +
                "设计培训,PHP培训,软件测试培训,产品经理培训等服务。");

        Article article = new Article();
        article.setAid(6);
        article.setTitle("6程序员介绍");
        article.setAuthor("6程序员");
        article.setCreateTime(new Date());
        article.setArticleData(articleData);

        articleService.updateArticle(article);
    }

    /**
     * 删除文章
     */
    @Test
    public void testDeleteArticle() {
        articleService.deleteByAid(6);
    }

    /**
     * 添加评论
     */
    @Test
    public void testSaveComment() {

        Comment comment = new Comment();
        comment.setCid(UUID.randomUUID().toString());
        comment.setAid(3);
        comment.setComment("2程序员真棒!!!");
        comment.setNickname("2程序员");
        commentService.saveComment(comment);
    }

    /**
     * 删除评论
     */
    @Test
    public void testDeleteComment() {
        commentService.deleteByCid("3974c94a-384e-4b1f-9eb2-64d72896054d");
    }
}

5.2.7.2 前台查看测试

/**
 * 前台查看测试
 *
 * @author wgy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ViewTest {

    @Autowired
    private ArticleService articleService;

    @Autowired
    private CommentService commentService;

    /**
     * 最新文章列表
     */
    @Test
    public void testFindNewArticleList() {
        List<Article> list = articleService.findNewArticleList();
        for (Article article : list) {
            System.out.println(article);
        }
    }

    /**
     * 根据文章获取评论
     */
    @Test
    public void testFindCommentsByAid() {
        List<Comment> comments = commentService.findCommentsByAid(3);
        for (Comment comment : comments) {
            System.out.println(comment);
        }
    }

    /**
     * 文章全文检索
     */
    @Test
    public void testSearch() {
        List<EsArticle> esArticles = articleService.search(0, 10, "程序员");
        for (EsArticle esArticle : esArticles) {
            System.out.println(esArticle);
        }
    }
}