@Controller
public class DemoController {
       @RequestMapping("/demo")
       public String demo(Model model) {
               List<Map<String, Object>> users = new ArrayList<>();
               for (int i = 0; i < 3; i++) {
                       Map<String, Object> user = new HashMap<>();
                       user.put("id",  i);
                       user.put("name", "Hello Spring FreeMarker");
                       users.add(user);
               }
               model.addAttribute("users", users);
               return "demo";
       }
}

package com.hu.controller;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class ProducerHello {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    @RequestMapping("hello")
    @ResponseBody
    public String sendHello() {
        CorrelationData correlationId = new CorrelationData("000001");
        //rabbitTemplate是使用springboot 提供的默认实现
        System.out.println("------------1-----------");
        this.rabbitTemplate.convertAndSend(correlationId.getId(), "Hello");
        return "Send Success";
    }
}

package com.hu.receiver;

import com.hu.config.RabbitMQConfig;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者
 */
@Component
//监听队列
@RabbitListener(queues = RabbitMQConfig.QUEUE_NAME)
public class DemoReceiver {

    @RabbitHandler //指定消息的处理方法
    public void handleMessage(String message) throws Exception {
        System.out.println("------------2-----------");
        // 处理消息
        System.out.println("handleMessage :" + message);
    }

}

@Configuration
public class RabbitMQConfig {

    public static final String QUEUE_NAME="hello";
    /**
     * 创建一个队列，也可以去队列管理器中手动创建一个
     * @return
     */
    @Bean
    public Queue Queue() {
        return new Queue(QUEUE_NAME);
    }
}

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

public class HelloController extends SpringBootServletInitializer{
    @RequestMapping("hello")
        String hello() {
        return "Hello World!";
    }
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
    }
}

package com.hu.mapper;

import com.hu.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface UserMapper {
    /**
     * 查询所有用户
     *
     * @return
     */
    @Select("SELECT * FROM users")
    @Results({
            @Result(property = "id", column = "id" ),
            @Result(property = "name", column = "name"),
            @Result(property = "userName", column = "useName"),
            @Result(property = "passWord", column = "passWord"),
            @Result(property = "age", column = "age")
    })
    List<User> getAll();

    /**
     * 查询单个用户
     *
     * @param id 用户ID
     * @return
     */
    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(int id);

    /**
     * 插入用户
     *
     * @param user 用户对象
     */
    @Insert("INSERT INTO users VALUES(default,#{name}, #{passWord}, #{userName}, #{age})")
    void insert(User user);

    /**
     * 更新用户信息
     *
     * @param user
     */
    @Update("UPDATE users SET name=#{name},userName=#{userName},passWord=#{passWord},age=#{age} WHERE id =#{id}")
    void update(User user);


    /**
     * 删除指定用户
     *
     * @param id
     */
    @Delete("DELETE FROM users WHERE id =#{id}")
    void delete(int id);
}

package com.hu.pojo;

public class User {
    private int id;
    private String name;
    private String passWord;
    private String userName;
    private int age;

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPassWord() {
        return passWord;
    }

    public String getUserName() {
        return userName;
    }

    public int getAge() {
        return age;
    }

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

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

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", passWord='" + passWord + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }

    public User(String name, String passWord, String userName, int age) {
        this.name = name;
        this.passWord = passWord;
        this.userName = userName;
        this.age = age;
    }
    public User(int id, String name, String passWord, String userName, int age) {
        this.id = id;
        this.name = name;
        this.passWord = passWord;
        this.userName = userName;
        this.age = age;
    }
}

 import com.hu.AppData;
import com.hu.mapper.UserMapper;
import com.hu.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Arrays;
import java.util.List;


@RunWith(SpringRunner.class)
@SpringBootTest(classes=AppData.class)
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void test() throws Exception {
        System.out.println("------------------------插入数据之前：-----------------------------");
        List<User> users = userMapper.getAll();
        System.out.println(Arrays.toString(users.toArray()));
        System.out.println("------------------------插入数据之后：-----------------------------");
        userMapper.insert(new User("黄晓明","1111","huang",111));
        users = userMapper.getAll();
        System.out.println(Arrays.toString(users.toArray()));
        System.out.println("------------------------获取ID为1-----------------------------");
        User user = userMapper.getUserById(1);
        System.out.println(user);
        System.out.println("------------------------更新ID为1-----------------------------");
        user.setName("张真人");
        userMapper.update(user);
        System.out.println("------------------------更新ID为1后-----------------------------");
        System.out.println(userMapper.getUserById(1));
        System.out.println("------------------------删除ID为2后-----------------------------");
        userMapper.delete(2);
        users = userMapper.getAll();
        System.out.println(Arrays.toString(users.toArray()));
    }
}

package com.hu;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig  extends CachingConfigurerSupport {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;

    //自定义缓存key生成策略
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator(){
            @Override
            public Object generate(Object target, java.lang.reflect.Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for(Object obj:params){
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    //缓存管理器
    @Bean
    public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //设置缓存过期时间
        cacheManager.setDefaultExpiration(10000);
        return cacheManager;
    }
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate(factory);
        //设置序列化工具
        setSerializer(template);
        return template;
    }
    @SuppressWarnings("all")
    private void setSerializer(StringRedisTemplate template){
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //查看Redis的Bean定义发现，对key的序列化使用的是StringRedisSerializer系列化，value值的序列化是GenericJackson2JsonRedisSerializer的序列化方法。
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
    }
}

 package com.hu;

public class User implements java.io.Serializable{
    private int id;
    private String name;
    private String passWord;
    private String userName;
    private int age;

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPassWord() {
        return passWord;
    }

    public String getUserName() {
        return userName;
    }

    public int getAge() {
        return age;
    }

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

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

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", passWord='" + passWord + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }

    public User(String name, String passWord, String userName, int age) {
        this.name = name;
        this.passWord = passWord;
        this.userName = userName;
        this.age = age;
    }
    public User(int id, String name, String passWord, String userName, int age) {
        this.id = id;
        this.name = name;
        this.passWord = passWord;
        this.userName = userName;
        this.age = age;
    }
    public User(){}
}

@SpringBootApplication
@EnableCaching//开启缓存
public class Application {
    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);
    }
}

package com.hu;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.TimeUnit;

//@RunWith(SpringJUnit4ClassRunner.class)
@RunWith(SpringRunner.class)
@SpringBootTest(classes=Application.class)
public class TestRedis {

    /**
     * StringRedisTemplate与RedisTemplate
     *
     * 两者的关系是StringRedisTemplate继承RedisTemplate。
     * 也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，
     * RedisTemplate只能管理RedisTemplate中的数据。
     *
     * SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
     * StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。
     * RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。
     *
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate redisTemplate;

    //手动使用的方式缓存
    @Test
    public void test() throws Exception {
        stringRedisTemplate.opsForValue().set("hu", "123");
        System.out.println(stringRedisTemplate.opsForValue().get("hu"));

        User user=new User("何晓明","123456","hexiaoming",22);
        ValueOperations<String, User> operations=redisTemplate.opsForValue();
        operations.set("user1", user);
        operations.set("user2",user,1, TimeUnit.SECONDS);
        Thread.sleep(1000);
        System.out.println(redisTemplate.hasKey("user2"));
        operations.set("user3", user);
        //redisTemplate.delete("user3");
        //System.out.println(operations.get("user1"));
    }
    
    @Autowired
    UserController userController;
    @Test
    public void userQues(){
        System.out.println(userController.user());
    }
}
@Service
class UserController{
    //自动根据方法生成缓存
    @Cacheable(value="user-key")//value的值就是缓存到redis中的key
    public User user() {
        User user= selUser();
        return user;
    }
    public User selUser(){
        System.out.println("redis缓存中没有，调用");//模拟查询数据库操作
        return new User("何晓明","123456","hexiaoming",22);
    }
}

/**
 * maxInactiveIntervalInSeconds: 设置Session失效时间，
 * 使用Redis Session之后，原Boot的server.session.timeout属性不再生效
 */
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 86400*30)
public class SessionConfig {
}

 @RequestMapping("/uid")
public String uid(HttpSession session) {
    UUID uid = (UUID) session.getAttribute("uid");
    if (uid == null) {
        uid = UUID.randomUUID();
    }
    session.setAttribute("uid", uid);
    return session.getId();
}

@Configuration
   protected static class RedisConfiguration {
       protected RedisConfiguration() {
       }

       @Bean
       @ConditionalOnMissingBean(
           name = {"redisTemplate"}
       )
       public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
           RedisTemplate<Object, Object> template = new RedisTemplate();
           template.setConnectionFactory(redisConnectionFactory);
           return template;
       }

       @Bean
       @ConditionalOnMissingBean({StringRedisTemplate.class})
       public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
           StringRedisTemplate template = new StringRedisTemplate();
           template.setConnectionFactory(redisConnectionFactory);
           return template;
       }
   }

package com.hu.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        //序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;

    }
}