spring boot 中的注解使用

spring 相关的注解

@Configuration

@bean

@@RestController
相当于 @controller+@responseBody
@GetMapping("")
相当于 requestMapping
@MapperScan(“com.example.demo.dao”)
扫描 包下面的所有类，注册到容器中

@SpringBootApplication

参考:

https://blog.csdn.net/hyhanyu/article/details/84628139

@Configuration //表示这个一个配置类，相当于spring的xml 文件
public class RabbitDDyiQueueConfig {
 
    public static final String DDYI_QUEUE = "DDYI_QUEUE";
 
    public static final String DDYI_DIRECTEXCHANGE = "DDYI_DIRECTEXCHANGE";
 
    public static final String DDYI_SEND_ROUTEKEY = "DDYI_SEND_ROUTEKEY";
 
    /**
     * 
     * @return
     */
    @Bean //相当于spring <bean id="ddyiQueue"  class = "org.springframework.amqp.core.Queue"> 默认的名称 就是方法名
    public Queue ddyiQueue(){
        return new Queue(DDYI_QUEUE);
    }
 
 
 
    @Bean
    public DirectExchange ddDirectExchange() {
        return new DirectExchange(DDYI_DIRECTEXCHANGE);
    }
 
    @Bean //如果需要传参数，直接加方法，默认参数按照类型匹配，如果多个参数，需要加@Qualifier("方法名称")
    public Binding DDBinding1a(@Qualifier("ddDirectExchange") DirectExchange directExchange,@Qualifier("ddyiQueue") Queue ddyiQueue) {
        return BindingBuilder.bind(ddyiQueue).to(directExchange).with(DDYI_SEND_ROUTEKEY);
 
    }
 
 
    @Bean
    public Binding DDBinding1a() {
        return BindingBuilder.bind(ddyiQueue()). //这和上面在方法里指定参数 不一样，确实现了相同的功能。
                // 因为spring boot 会对 加了@bean的方法 进行拦截。通过BeanMethodInterceptor这个拦截器，
                //如果  ddyiQueue() 的对象 没有初始化 ，会进行初始化并且放在单列map中，如果初始化了，直接从单列map中获取
                //如果 传的参数 没有 @Bean 这种类型注解，拦截器不会进行拦截，正常调用对应的set方法进行赋值
                to(ddDirectExchange()).
                with(DDYI_SEND_ROUTEKEY);
 
    }
 
 
}

@slf4j
直接获取log对象，记录日志

@Lazy
效果：一般情况下，Spring容器在启动时会创建所有的Bean对象，使用@Lazy注解可以将Bean对象的创建延迟到第一次使用Bean的时候

@RestController

@RestController注解相当于@Controller + @ResponseBody 合在一起的作用。

@PostMapping

post 请求

@GetMapping

get请求

@RequiredArgsConstructor(onConstructor = @__(@Autowired))

对lombok插件的描述

mybatis 相关的注解和类

redis 相关的注解和类

工具类

package com.example.demo.utils;

import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**
 * 
 * @Title: RedisOperator.java
 * @Package com.weiz.util
 * @Description: 使用redisTemplate的操作实现类 Copyright: Copyright (c) 2016
 * 
 * @author jiangcl
 * @date 2017年9月29日 下午2:25:03
 * @version V1.0
 */
@Component
public class RedisOperator {
   
// @Autowired
//    private RedisTemplate<String, Object> redisTemplate;
   
   @Autowired
   private StringRedisTemplate redisTemplate;
   
   // Key（键），简单的key-value操作

   /**
    * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
    * 
    * @param key
    * @return
    */
   public long ttl(String key) {
      return redisTemplate.getExpire(key);
   }
   
   /**
    * 实现命令：expire 设置过期时间，单位秒
    * 
    * @param key
    * @return
    */
   public void expire(String key, long timeout) {
      redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
   }
   
   /**
    * 实现命令：INCR key，增加key一次
    * 
    * @param key
    * @return
    */
   public long incr(String key, long delta) {
      return redisTemplate.opsForValue().increment(key, delta);
   }

   /**
    * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key
    */
   public Set<String> keys(String pattern) {
      return redisTemplate.keys(pattern);
   }

   /**
    * 实现命令：DEL key，删除一个key
    * 
    * @param key
    */
   public void del(String key) {
      redisTemplate.delete(key);
   }

   // String（字符串）

   /**
    * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
    * 
    * @param key
    * @param value
    */
   public void set(String key, String value) {
      redisTemplate.opsForValue().set(key, value);
   }

   /**
    * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒）
    * 
    * @param key
    * @param value
    * @param timeout
    *            （以秒为单位）
    */
   public void set(String key, String value, long timeout) {
      redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
   }

   /**
    * 实现命令：GET key，返回 key所关联的字符串值。
    * 
    * @param key
    * @return value
    */
   public String get(String key) {
      return (String)redisTemplate.opsForValue().get(key);
   }

   // Hash（哈希表）

   /**
    * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
    * 
    * @param key
    * @param field
    * @param value
    */
   public void hset(String key, String field, Object value) {
      redisTemplate.opsForHash().put(key, field, value);
   }

   /**
    * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
    * 
    * @param key
    * @param field
    * @return
    */
   public String hget(String key, String field) {
      return (String) redisTemplate.opsForHash().get(key, field);
   }

   /**
    * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
    * 
    * @param key
    * @param fields
    */
   public void hdel(String key, Object... fields) {
      redisTemplate.opsForHash().delete(key, fields);
   }

   /**
    * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
    * 
    * @param key
    * @return
    */
   public Map<Object, Object> hgetall(String key) {
      return redisTemplate.opsForHash().entries(key);
   }

   // List（列表）

   /**
    * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头
    * 
    * @param key
    * @param value
    * @return 执行 LPUSH命令后，列表的长度。
    */
   public long lpush(String key, String value) {
      return redisTemplate.opsForList().leftPush(key, value);
   }

   /**
    * 实现命令：LPOP key，移除并返回列表 key的头元素。
    * 
    * @param key
    * @return 列表key的头元素。
    */
   public String lpop(String key) {
      return (String)redisTemplate.opsForList().leftPop(key);
   }

   /**
    * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。
    * 
    * @param key
    * @param value
    * @return 执行 LPUSH命令后，列表的长度。
    */
   public long rpush(String key, String value) {
      return redisTemplate.opsForList().rightPush(key, value);
   }

}