Spring Boot—18Redis

pom.xml

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.9</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--  因为采用了Redis连接池，所以要引用commons-pool2   -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.5.0</version>
</dependency>

application.properties

#
server.address=0.0.0.0
server.port=8080
server.servlet.context-path=/test
server.session.timeout=300
server.error.path=/error
#
server.tomcat.accesslog.enabled=true
server.tomcat.accesslog.buffered=true
server.tomcat.accesslog.directory=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/logs
#
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=Asia/Shanghai
#
spring.thymeleaf.cache=true
spring.thymeleaf.enabled=true

file.upload.path=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/fileUpLoad

spring.servlet.multipart.enabled=true
spring.servlet.multipart.file-size-threshold=0
spring.servlet.multipart.location=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/temp
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB
spring.servlet.multipart.resolve-lazily=false

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.one.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.druid.one.username=root
spring.datasource.druid.one.password=gis
spring.datasource.druid.one.driver-class-name=com.mysql.cj.jdbc.Driver

##Druid
spring.datasource.druid.one.initial-size=2
spring.datasource.druid.one.max-active=5
spring.datasource.druid.one.min-idle=1
spring.datasource.druid.one.max-wait=60000
spring.datasource.druid.one.pool-prepared-statements=true
spring.datasource.druid.one.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.one.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.one.validation-query-timeout=60000
spring.datasource.druid.one.test-on-borrow=false
spring.datasource.druid.one.test-on-return=false
spring.datasource.druid.one.test-while-idle=true
spring.datasource.druid.one.time-between-eviction-runs-millis=60000
spring.datasource.druid.one.min-evictable-idle-time-millis=100000
#spring.datasource.druid.one.max-evictable-idle-time-millis=
spring.datasource.druid.one.filters=stat,wall,log
spring.datasource.druid.one.logSlowSql=true

#
# debug=true # Enable debug logs.
# trace=true # Enable trace logs.

spring.redis.host=127.0.0.1
spring.redis.password=gis
spring.redis.port=6379
spring.redis.pool.max-active=8
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.max-wait=-1ms
spring.redis.jedis.pool.min-idle=0
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.shutdown-timeout=100ms
spring.redis.ssl=false
spring.redis.timeout=5000

redis.message.topic=spring.news.*

启动类

package com.smartmap.sample.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.smartmap.sample.test.conf.DataSourceConfiguration;

@EnableTransactionManagement
@SpringBootApplication
public class TestRedisApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestRedisApplication.class, args);

    }

}

注册Redis消息监听

package com.smartmap.sample.test.conf;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Value;
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.StringRedisTemplate;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import com.smartmap.sample.test.message.RedisMessageListener;

@Configuration
public class RedisChannelListenerConfiguration {
    Log log = LogFactory.getLog(RedisChannelListenerConfiguration.class);

    @Value("${redis.message.topic}")
    private String topic;

    /**
     * 注册Redis事件监听
     * publish spring.news.user bobobo
     *
     * @param connectionFactory
     * @param listenerAdapter
     * @return
     */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
            RedisMessageListener listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic(topic));
        log.info("------------> " + topic);
        return container;
    }

    @Bean
    StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
    }
}

Redis消息处理类

package com.smartmap.sample.test.message;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisMessageListener implements MessageListener {
    final Log log = LogFactory.getLog(RedisMessageListener.class);

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void setRedisTemplate(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public void onMessage(Message message, byte[] pattern) {
        byte[] bodyByte = message.getBody();
        byte[] channelByte = message.getChannel();
        String content = (String) stringRedisTemplate.getValueSerializer().deserialize(bodyByte);
        String topic = (String) stringRedisTemplate.getStringSerializer().deserialize(channelByte);
        log.info(topic + "    " + content);
    }
}

Redis配置类

package com.smartmap.sample.test.conf;

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.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class RedisConfiguration {

    @Bean("stringJsonRedisTemplate")
    public RedisTemplate<Object, Object> stringJsonRedisTemplate(RedisConnectionFactory redisConnectionFactory,
            ObjectMapper mapper) {
        RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer(mapper));
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);
        return template;
    }
}

JSON转换配置类

package com.smartmap.sample.test.conf;

import java.text.SimpleDateFormat;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class JacksonConfiguration {
    @Bean
    public ObjectMapper getObjectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        return objectMapper;
    }
}

实体类 User

package com.smartmap.sample.test.entity;

import java.util.Date;

import com.fasterxml.jackson.annotation.JsonBackReference;

public class User {

    private Long id;

    private String name;

    @JsonBackReference // 防止相互引用，出现无限引用递归
    private Department department;

    private Date createTime;

    public User() {
    }

    public User(Long id, String name, Department department, Date createTime) {
        super();
        this.id = id;
        this.name = name;
        this.department = department;
        this.createTime = createTime;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    public Long getDepartmentId() {
        return this.department == null ? null : this.department.getId();
    }

    public void setDepartmentId(Long departmentId) {
        if (this.department != null) {
            this.department.setId(departmentId);
        }
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

}

实体类Department

package com.smartmap.sample.test.entity;

import java.util.HashSet;
import java.util.Set;
import com.fasterxml.jackson.annotation.JsonManagedReference;

public class Department {

    private Long id;

    private String name;

    @JsonManagedReference  // 防止相互引用，出现无限引用递归
    private Set<User> users = new HashSet<User>();

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<User> getUsers() {
        return users;
    }

    public void setUsers(Set<User> users) {
        this.users = users;
    }
}

DAO类

package com.smartmap.sample.test.dao.impl;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Repository;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.smartmap.sample.test.dao.UserDao;
import com.smartmap.sample.test.entity.User;

@Repository
public class UserDaoImpl implements UserDao {
    final Log log = LogFactory.getLog(UserDaoImpl.class);

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    @Qualifier("stringJsonRedisTemplate")
    private RedisTemplate<Object, Object> redisTemplate;

    public Long addRootUser(User user) {
        String key = "info:root:user";
        redisTemplate.opsForValue().set(key, user);

        Object obj = redisTemplate.opsForValue().get(key);
        // 因为返回来的是HashMap对象，需要将其转化为实体对象
        User userResult = objectMapper.convertValue(obj, User.class);
        // User userResult = (User) redisTemplate.opsForValue().get(key);
        if (userResult != null) {
            return 1L;
        }
        return 0L;
    }

    public User getRootUser() {
        String key = "info:root:user";
        Object obj = redisTemplate.opsForValue().get(key);
        // 因为返回来的是HashMap对象，需要将其转化为实体对象
        User userResult = objectMapper.convertValue(obj, User.class);
        return userResult;
    }

    public Long addUser(User user) {
        String key = "info:users";
        Long count = redisTemplate.opsForList().leftPush(key, user);
        return count;
    }

    public List<User> getUsers() {
        String key = "info:users";
        List<Object> objectList = (List<Object>) (redisTemplate.opsForList().range(key, 0, -1));
        // 因为返回来的是HashMap对象，需要将其转化为实体对象
        List<User> userList = new ArrayList<User>();
        // 此处用到了Java的Lambda表达式进行转化
        objectList.forEach((k) -> {
            userList.add(objectMapper.convertValue(k, User.class));
        });

        return userList;
    }

    public Long removeUser(Long userId) {
        String key = "info:users";
        User user = (User) redisTemplate.opsForList().leftPop(key);
        return user != null ? 1L : 0L;
    }
    
    // 调用Redis原始的API来进行操作
    public String connectionSet(final String key, final String value) {
        Object obj = redisTemplate.execute(new RedisCallback<Object>() {

            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                String message = "fail";
                try {
                    Boolean isSuccess = connection.set(key.getBytes("UTF-8"), value.getBytes("UTF-8"));
                    if (isSuccess) {
                        message = "success";
                    }
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException(e);
                }
                return message;
            }
        });
        if (obj != null) {
            return "success";
        } else {
            return "fail";
        }

    }

}

Service类

package com.smartmap.sample.test.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.smartmap.sample.test.dao.UserDao;
import com.smartmap.sample.test.entity.User;
import com.smartmap.sample.test.service.UserService;

@Service
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    UserDao userDao;

    public Long addRootUser(User user) {
        return userDao.addRootUser(user);
    }

    public User getRootUser() {
        return userDao.getRootUser();
    }

    public Long addUser(User user) {
        return userDao.addUser(user);
    }

    public List<User> getAllUsers() {
        return userDao.getUsers();
    }

    public Long delete(Long userId) {
        return userDao.removeUser(userId);
    }

    public String generateSave(String key, String value) {
        return userDao.connectionSet(key, value);
    }
}

Controller类

package com.smartmap.sample.test.controller.rest;

import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.smartmap.sample.test.entity.User;
import com.smartmap.sample.test.service.UserService;

@RestController
@RequestMapping("/api/v1.1/system/user")
public class UserRestController {
    private final Log logger = LogFactory.getLog(UserRestController.class);

    @Autowired
    UserService userService;

    /**
     * 查询所有用户
     *
     * curl -XGET 'http://127.0.0.1:8080/test/api/v1.1/system/user/'
     *
     * @return
     */
    @GetMapping("/")
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    /**
     * 添加用户
     *
     * curl -XPOST 'http://127.0.0.1:8080/test/api/v1.1/system/user/'
     * -H'Content-type:application/json;charset=UTF-8' -d ' { "name":"123",
     * "createTime":"2017-01-01 00:00:00", "departmentId":"9" }'
     *
     * @param user
     * @return
     */
    @PostMapping("/")
    public Long addUse(@RequestBody User user) {
        System.out.println(user.getName());
        return userService.addUser(user);
    }

    /**
     * 添加用户
     *
     * curl -XPOST 'http://127.0.0.1:8080/test/api/v1.1/system/user/root'
     * -H'Content-type:application/json;charset=UTF-8' -d ' { "name":"123",
     * "createTime":"2017-01-01 00:00:00", "departmentId":"9" }'
     *
     * @param user
     * @return
     */
    @PostMapping("/root")
    public Long addRootUse(@RequestBody User user) {
        System.out.println(user.getName());
        return userService.addRootUser(user);
    }

    /**
     * 查询所有用户
     *
     * curl -XGET 'http://127.0.0.1:8080/test/api/v1.1/system/user/root'
     *
     * @return
     */
    @GetMapping("/root")
    public User getRootUser() {
        return userService.getRootUser();
    }

    /**
     * 删除用户
     *
     * curl -XDELETE 'http://127.0.0.1:8080/test/api/v1.1/system/user/123'
     *
     * @param userId
     * @return
     */
    @DeleteMapping("/{userId}")
    public String deleteUser(@PathVariable("userId") Long userId) {
        Long count = userService.delete(userId);
        if (count > 0) {
            return "{success:true, message:'delete success'}";
        } else {
            return "{success:false, message:'delete fail'}";
        }
    }

    /**
     * 添加用户
     *
     * curl -XPOST 'http://127.0.0.1:8080/test/api/v1.1/system/user/generate'
     * -H'application/x-www-form-urlencoded;charset=UTF-8' -d 'key=key1&value=value1'
     *
     * @param user
     * @return
     */
    @PostMapping("/generate")
    public String generateSave(@RequestParam("key") String key, @RequestParam("value") String value) {
        String result = userService.generateSave(key, value);
        return result;
    }

}

完！