redis集群springboot连接

谢谢参考:https://blog.csdn.net/CNZYYH/article/details/85696674

 

一般来说,消息队列有两种场景,一种是发布者订阅者模式,一种是生产者消费者模式。利用redis这两种场景的消息队列都能够实现。
定义:

  • 生产者消费者模式 :生产者生产消息放到队列里,多个消费者同时监听队列,谁先抢到消息谁就会从队列中取走消息;即对于每个消息只能被最多一个消费者拥有。
  • 发布者订阅者模式:发布者生产消息放到队列里,多个监听队列的消费者都会收到同一份消息;即正常情况下每个消费者收到的消息应该都是一样的。

Redis不仅可作为缓存服务器,还可用作消息队列。它的列表类型天生支持用作消息队列。如下图所示:
在这里插入图片描述
由于Redis的列表是使用双向链表实现的,保存了头尾节点,所以在列表头尾两边插取元素都是非常快的。

在Redis中,List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样,我们可以在其头部(left)和尾部(right)添加新的元素。在插入时,如果该键并不存在,Redis将为该键创建一个新的链表。与此相反,如果链表中所有的元素均被移除,那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4294967295。
从元素插入和删除的效率视角来看,如果我们是在链表的两头插入或删除元素,这将会是非常高效的操作,即使链表中已经存储了百万条记录,该操作也可以在常量时间内完成。然而需要说明的是,如果元素插入或删除操作是作用于链表中间,那将会是非常低效的。相信对于有良好数据结构基础的开发者而言,这一点并不难理解。

Redis List的主要操作为lpush/lpop/rpush/rpop四种,分别代表从头部和尾部的push/pop,除此之外List还提供了两种pop操作的阻塞版本blpop/brpop,用于阻塞获取一个对象。

Redis通常都被用做一个处理各种后台工作或消息任务的消息服务器。 一个简单的队列模式就是:生产者把消息放入一个列表中,等待消息的消费者用 RPOP 命令(用轮询方式), 或者用 BRPOP 命令(如果客户端使用阻塞操作会更好)来得到这个消息。

以下列举SpringBoot集成redis的JedisCluster和RedisTemplate

引入依赖到pom.xml

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>jcl-over-slf4j</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

application.yml增加redis集群配置

spring:
  redis:
    password:
    clusters: 10.10.1.238:7000,10.10.1.238:7001,10.10.1.238:7002,10.10.1.238:7003,10.10.1.238:7004,10.10.1.238:7005

RedisConfig配置

package com.example.myframe.config;

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.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.lang.reflect.Field;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
	/**redis密码**/
	@Value("${spring.redis.password}")
	public String password;
	
	@Value("${spring.redis.clusters}")
	public String cluster;
	
    
    @Bean
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
			StringBuilder sb = new StringBuilder();
			sb.append(target.getClass().getName());
			sb.append(method.getName());
			for (Object obj : params) {
				sb.append(obj.toString());
			}
			return sb.toString();
		};
    }

	public  Object getFieldValueByObject (Object object , String targetFieldName) throws Exception {
		// 获取该对象的Class
		Class objClass = object.getClass();
		// 获取所有的属性数组
		Field[] fields = objClass.getDeclaredFields();
		for (Field field:fields) {
			// 属性名称
			field.setAccessible(true);
			String currentFieldName = field.getName();
			if(currentFieldName.equals(targetFieldName)){
				return field.get(object); // 通过反射拿到该属性在此对象中的值(也可能是个对象)
			}
		}
		return null;
	}

	/**
	 * 通过反射获取JedisCluster
	 * @param factory
	 * @return
	 */
	@Bean
	public JedisCluster redisCluster(RedisConnectionFactory factory){
		Object object =null;
		try {
			object= getFieldValueByObject(factory,"cluster");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (JedisCluster)object;

	}

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    	StringRedisTemplate template = new StringRedisTemplate(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);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
    
    @Bean(name="factory")
    public RedisConnectionFactory factory(RedisClusterConfiguration clusterConfig){
        JedisConnectionFactory redisConnectionFactory=new JedisConnectionFactory(clusterConfig);
        String redisPassword = password;
    	redisConnectionFactory.setPassword(redisPassword);
        redisConnectionFactory.setPoolConfig(createJedisPoolConfig());
        redisConnectionFactory.setTimeout(30000);
        redisConnectionFactory.setUsePool(true);  
        return redisConnectionFactory;  
    }
    
    @Bean(name="clusterConfig")
    public RedisClusterConfiguration clusterConfig(){
    	RedisClusterConfiguration config = new RedisClusterConfiguration();
    	String[] nodes = cluster.split(",");
    	for(String node : nodes){
    		String[] host =  node.split(":");
    		RedisNode redis = new RedisNode(host[0], Integer.parseInt(host[1]));
    		config.addClusterNode(redis);
    	}
    	
    	return config;
    }


    public JedisPoolConfig createJedisPoolConfig(){
   	 JedisPoolConfig config = new JedisPoolConfig();
   	//连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
   	 config.setBlockWhenExhausted(false);
   	  
   	 //设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
   	 config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
   	  
   	 //是否启用pool的jmx管理功能, 默认true
   	 config.setJmxEnabled(true);
   	  
   	 //MBean ObjectName = new ObjectName("org.apache.commons.pool2:type=GenericObjectPool,name=" + "pool" + i); 默 认为"pool", JMX不熟,具体不知道是干啥的...默认就好.
   	 config.setJmxNamePrefix("pool");
   	  
   	 //是否启用后进先出, 默认true
   	 config.setLifo(true);
   	  
   	 //最大空闲连接数, 默认8个
   	 config.setMaxIdle(2000);
   	  
   	 //最大连接数, 默认8个
   	 config.setMaxTotal(5000);
   	 
   	 //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
   	 config.setMaxWaitMillis(10000);
   	  
   	 //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
   	 config.setMinEvictableIdleTimeMillis(1800000);
   	  
   	 //最小空闲连接数, 默认0
   	 config.setMinIdle(0);
   	  
   	 //每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
   	 config.setNumTestsPerEvictionRun(3);
   	  
   	 //对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断  (默认逐出策略)   
   	 config.setSoftMinEvictableIdleTimeMillis(1800000);
   	  
   	 //在获取连接的时候检查有效性, 默认false
   	 config.setTestOnBorrow(false);
   	  
   	 //在空闲时检查有效性, 默认false
   	 config.setTestWhileIdle(false);
   	  
   	 //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
   	 config.setTimeBetweenEvictionRunsMillis(-1);
   	 
   	 return config;
   }
    

}

RedisService.java辅助类

package com.example.myframe.redis.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service("redisService")
public class RedisService {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0){
        	redisTemplate.delete(keys);
        }
            
    }
    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }

    /**
     * 哈希 获取哈希的key集合
     * @param key
     * @return
     */
    public Set<Object> hmKeys(String key){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.keys(key);        
    }

    /**
     * 哈希 删除哈希的key
     * @param key
     * @param hashKey
     */
    public void hmDelete(String key,String hashKey){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.delete(key, hashKey);       
    }    
    
    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key,hashKey);
    }
    
    /**
     * 获取所有key值
     * @param key
     * @return
     */
    public Set<Object>  hmKeySet(String key){
    	HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    	return hash.keys(key);	
    }
    
    /**
     * 获取所有key值
     * @param key
     * @return
     */
    public void  hmRemove(String key, Object hashKey){
    	HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    	hash.delete(key, hashKey); 	
    }
    
    
    

    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k,Object v){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k,v);
    }

    /**
     * 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k,l,l1);
    }

    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key,Object value){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key,value);
    }

    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 集合长度
     * @param key
     * @return
     */
    public Long setSize(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.size(key);
    }


    /**
     * 集合获取
     * @param key
     * @param count
     * @return
     */
    public Set<Object> setMembers(String key, int count){
    	 SetOperations<String, Object> set = redisTemplate.opsForSet();
    	 return set.distinctRandomMembers(key, count);
    }
    
    /**
     * 删除集合数据
     * @param key
     * @param value
     */
    public void remove(String key, Object value){
    	 SetOperations<String, Object> set = redisTemplate.opsForSet();
    	 set.remove(key, value);
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key,value,scoure);
    }

    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
    
    /**
     * 消息队列实现
     * @param channel
     * @param message
     */
    public void convertAndSend(String channel, Object message){
    	redisTemplate.convertAndSend(channel, message);
    }
    
    /**
     * 数列添加
     * @param key
     * @param value
     */
    public void addList(String key,Object value){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(key, value);
    }

    /**
     * 数列获取
     * @param key
     * @return
     */
    public List<Object> getList(String key){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(key, 0, list.size(key));
    }
    
    /**
     * 左弹出数列
     * @param key
     * @return
     */
    public Object popList(String key) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.leftPop(key);
    }

    public Long increment(String k, Long l) {
        return redisTemplate.opsForValue().increment(k, l);
    }
    
}

TestRedisController.java

package com.example.myframe.controller;

import com.example.myframe.redis.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/redis")
public class TestRedisController {
	@Autowired
	RedisUtil redisUtil;

	/**
	 * 生产者 通过此方法来往redis的list的尾部插入数据
	 */
	@RequestMapping("/shengchangzhe")
	public void shengChangZhe() {
		redisUtil.dealShengChangZhe();
	}

	/**
	 * 消费者 ,通过此方法往redis的list的头部获取数据,直到list没有数据 阻塞,等到一有数据又继续获取
	 */
	@RequestMapping("/xiaoFeiZhe")
	public void xiaoFeiZhe() {
		redisUtil.dealXiaoFeiZhe();
	}

	/**
	 * 发布者,发布信息,监听器一旦接收到监听,就进行操作
	 */
	@RequestMapping("/faBuDingYue")
	public void faBuDingYue() {
		redisUtil.dealFaBuDingYue();
	}

}
package com.example.myframe.redis;

import com.example.myframe.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisCluster;

import java.util.List;

@Component
public class RedisUtil {
	@Autowired
	JedisCluster jedisCluster;

	@Autowired
	private RedisService redisService;

	/**
	 * 生产者
	 */
	public void dealShengChangZhe() {
		for (int i = 0; i < 10; i++) {
			jedisCluster.rpush("ceshi", "value1_" + i);
		}
	}

	/**
	 * 消费者
	 */
	public void dealXiaoFeiZhe() {
		while (true) {
			//阻塞式brpop,List中无数据时阻塞,参数0表示一直阻塞下去,直到List出现数据
			List<String> listingList = jedisCluster.blpop(0, "ceshi");
			System.out.println("线程取数据:{}" + listingList.get(1));
		}
	}

	/**
	 * 发布订阅模式
	 */
	public void dealFaBuDingYue() {
		redisService.convertAndSend("dealFaBuDingYue", "我是来发布信息的");
	}
}

redis消息队列监听信息

package com.example.myframe.redis.msg;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

@Configuration
public class RedisMsgListener {
	@Autowired
	Receiver receiver;

	/**
	 * redis消息队列监听信息
	 * 
	 * @param connectionFactory
	 * @param listenerAdapter
	 * @return
	 */
	@Bean
	RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
											MessageListenerAdapter listenerAdapter) {
		RedisMessageListenerContainer container = new RedisMessageListenerContainer();
		container.setConnectionFactory(connectionFactory);
		container.addMessageListener(listenerAdapter, new PatternTopic("dealFaBuDingYue"));
		return container;
	}

	/**
	 * 监听方法
	 * 
	 * @return
	 */
	@Bean(name = "listenerAdapter")
	MessageListenerAdapter listenerAdapter() {
		// 回调数据处理方法
		return new MessageListenerAdapter(receiver, "dealJt");
	}
}

package com.example.myframe.redis.msg;

import com.example.myframe.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

@Service("receiver")
public class Receiver{

	@Autowired
	private RedisService redisService;
	@Autowired
	private StringRedisTemplate redisTemplate;

    /**
     * 清除外部广告位本地缓存
     * @param message
     */
    public  void dealJt(String message){
        System.out.println("我是用来监听信息的");
        System.out.println(message);
    }

	/**
	 * 清除外部广告位本地缓存
	 * @param message
	 */
	public  void dealJt1(String message){
		System.out.println("我是用来监听信息的1");
		System.out.println(message);
	}


}

热门文章

暂无图片
编程学习 ·

vue打包后修改服务器地址

1.在public文件下新建config.js文件2.修改config.js文件 var PLATFROM_CONFIG = {}; // 本地环境 PLATFROM_CONFIG.baseUrl = "服务器地址" // 正式环境 // PLATFROM_CONFIG.baseUrl = "服务器地址"3.在封装好的axios里面去修改,我的是4.在index.html中引…
暂无图片
编程学习 ·

GPS卫星位置计算(卫星位置计算小程序)

目录一、准备以及结果图二、数据三、计算四、全部代码附:一、准备以及结果图软件:eclipse(2020-6版本)带有WindowBuilder插件编程语言:Java结果图:二、数据t0e星历的基准时间单位:秒a_sqrt轨道半长轴的平方根单位:米e1轨道离心率单位:无量纲i0倾角(在 t0e时)单位:r…
暂无图片
编程学习 ·

几种室内定位方案技术对比,高精度室内定位方案-新导智能

从古至今,人类的方方面面就离不开“定位”技术,从古代远洋航海罗盘,再到现如今每个电子终端都有的GPS,定位技术在我们身边可谓是无处不在。但人类已经演变成生活在钢筋混凝土森林的动物,工作和生活在室内的时间要远远超过室外,而且室内同样有定位和导航的需求.室内定位方…
暂无图片
编程学习 ·

Vue动态缓存页面

原理通过keep-alive标签的include属性及vuex完成 需求说明:A页面到B页面需要缓存,A页面到C页面不需要缓存 所要缓存页面的顶级出口 <keep-alive :include="kpAlive"><router-view/> </keep-alive><script> export default {computed: {/**…
暂无图片
编程学习 ·

云原生已来,只是分布不均

作者 | 右京 阿里云交付专家 **导读:**云原生是什么?相信不同的人有不同的认识和解读。本文结合大家的各种讨论及项目实践经验,从交付的角度,分享阿里交付专家对云原生的理解,阐述如何构建云原生应用,云原生有哪些关键技术,以及关于云原生落地的思考。 前言 Internet 改…
暂无图片
编程学习 ·

日志框架 SLF4j

是什么:SLF4J,即简单日志门面(Simple Logging Facade for Java),不是具体的日志解决方案,它只服务于各种各样的日志系统。按照官方的说法,SLF4J是一个用于日志系统的简单Facade,允许最终用户在部署其应用时使用其所希望的日志系统为什么:在java.util.logging, logback…
暂无图片
编程学习 ·

转 C++常用设计模式

适配器模式可以将一个类的接口转换成客户端希望的另一个接口,使得原来由于接口不兼容而不能在一起工作的那些类可以在一起工作。通俗的讲就是当我们已经有了一些类,而这些类不能满足新的需求,此时就可以考虑是否能将现有的类适配成可以满足新需求的类。适配器类需要继承或依…
暂无图片
编程学习 ·

机器视觉打光技巧

光源专家的8个打光技巧 机器视觉系统中的照明系统是极其重要的一部分,它的好坏直接影响着后面的图像处理。在听了一位日本光源专家的讲座之前,我其实对照明并不太了解,不就是将图像照亮以至于相机能够拍到图像吗?但事实并非如此,照明远非增强图像亮度这样简单,好的照明系…
暂无图片
编程学习 ·

蓝桥杯-试题 算法训练 审美课-java

问题描述 《审美的历程》课上有n位学生,帅老师展示了m幅画,其中有些是梵高的作品,另外的都出自五岁小朋友之手。老师请同学们分辨哪些画的作者是梵高,但是老师自己并没有答案,因为这些画看上去都像是小朋友画的……老师只想知道,有多少对同学给出的答案完全相反,这样他就…
暂无图片
编程学习 ·

使用mimikatz获取机器的RDP凭据

当我们拿到了机器的管理员权限后,想获取其RDP凭据保存的密码。那么,该如何操作呢?#查看mstsc的连接纪录 cmdkey /list #查找本地的Credentials: dir /a %userprofile%\AppData\Local\Microsoft\Credentials\*上传mimikatz,执行以下命令:
暂无图片
编程学习 ·

微服务的全局异常处理器

如果是dubbo服务 直接在对外暴露服务的哪个模块添加该类即可 如果是springboot微服务 我们可以把他配置到网关里 并且在启动类配置如下目的是为了让服务知道该配置 否则不生效 ApiReturnObject是一个统一返回值类型 可以根据自己喜好进行定义 这里就不贴代码了package com.s…
暂无图片
编程学习 ·

css3属性选择器

属性选择器 基本用法选择符 简介E[att] 选择具有att属性的E元素E[att=val] 选择具有att属性且属性值等于val的E元素E[att^=“val”] 匹配具有att属性、且值以val开头的E元素E[att$=“val”] 匹配具有att属性、且值以val结尾的E元素E[att*=“val”] 匹配具有att属性、且值中含有…
暂无图片
编程学习 ·

mysql怎么连接navicat

可能出现下面的问题远程连接发现没有什么问题 在命令行 mysql可以正常使用执行三条指令就可以解决
暂无图片
编程学习 ·

备考第二天

系统论是研究系统的一般模式、结构和规律的科学。系统论的核心思想是整体观念。任何一个系统都是一个有机的整体,不是各个部件的机械组合和简单相加。系统的功能是各部件在孤立状态下所不具有的。系统论的能动性不仅在于认识系统的特点和规律,更重要地在于利用这些特点和规律去…
暂无图片
编程学习 ·

VsCode中自动调整格式

VsCode中使用了Prettier插件后会在保存后自动格式化样式 如果遇到不需要调整的代码时候,只要在前添加如下代码,就不会格式化 –// prettier-ignore
暂无图片
编程学习 ·

7月美团Java四面,成功拿下offer!分享这次的面试思路和复习方向

从去年到今年先后面试了 4次美团,外卖、订单、商旅面试了好几个部门,终于在今年年初成功拿下offer,总结下来各部门面试的大体思路基本都一致。比如: JVMJVM 参数配置、常用调试工具 分区、类加载 还会问你有需要线上的调试问题吗? 遇到死循环 CPU 飙升怎么解决?并发问题J…
暂无图片
编程学习 ·

FeignClient实现跨服务之间调用

首先在A服务写好接口新建这几个包跟类@FeignClient(contextId = "remoteSysDictService", value = ServiceNameConstants.AMS_SERVICE, fallbackFactory = RemoteSysDictServiceFallbackFactory.class) public interface RemoteSysDictService {@GetMapping("/s…
暂无图片
编程学习 ·

Unity通过代码实现预制体Apply保存

if (PrefabUtility.GetPrefabParent(weaponPanel.gameObject) != null) {PrefabUtility.ReplacePrefab(weaponPanel.gameObject,PrefabUtility.GetPrefabParent(weaponPanel), ReplacePrefabOptions.ConnectToPrefab); }