spring boot 中的注解使用

小咪咪 2022-11-15 11:56 172阅读 0赞

### spring boot 相关的注解 ###

*   *   *  spring 相关的注解
         *  mybatis 相关的注解和类
         *  redis 相关的注解和类

### spring 相关的注解 ###

@Configuration

@bean

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

@SpringBootApplication  
![组合注解 下面包含 config][_ config]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nd3VkaWRlYmFiYQ_size_16_color_FFFFFF_t_70]

参考:

[https://blog.csdn.net/hyhanyu/article/details/84628139][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);
       }
    
    }

[_ config]: /images/20221022/5ec552405ee3485087a8429a996277d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nd3VkaWRlYmFiYQ_size_16_color_FFFFFF_t_70]: /images/20221022/368bf16540224f5bb7b104610d985d30.png
[https_blog.csdn.net_hyhanyu_article_details_84628139]: https://blog.csdn.net/hyhanyu/article/details/84628139