Redis（Jedis和SpringBoot整合Redis）

文章目录

    • 1.Jedis
        • 1.介绍
        • 2.环境配置
          • 1.创建maven项目
          • 2.pom.xml引入依赖
          • 3.新建一个包并创建一个文件
        • 3.Jedis远程连接到Redis
          • 1.Redis放到服务器可以连接的前提条件
          • 2.为Redis设置密码
            • 1.编辑配置文件
            • 2.找到 requirepass
            • 3.设置密码为root
            • 4.重启Redis，在shutdown的时候报错，原因是之前连接到了redis的客户端没有关闭，执行下面的指令关闭
            • 5.然后再重启Redis，此时再次操作Redis就需要密码了
          • 3.编写代码连接Redis
        • 4.key操作
          • 1.代码
          • 2.结果
        • 5.string操作
          • 1.代码
          • 2.结果
        • 6.list操作
          • 1.代码
          • 2.结果
        • 7.set操作
          • 1.代码
          • 2.结果
        • 8.hash操作
          • 1.代码
          • 2.结果
        • 9.zset操作
          • 1.代码
          • 2.结果
    • 2.由于Redis被攻击了，所以重新配置
        • 1.修改端口为7489
        • 2.设置redis密码
        • 3.使redis支持远程访问
        • 4.重启redis
          • 1.指定配置文件启动redis
          • 2.查看是否启动
          • 3.指定端口连接redis
          • 4.测试密码
          • 5.如果要关闭redis，在命令行关闭redis，输入shutdown
        • 5.开放7489端口
          • 1.宝塔开启端口
          • 2.腾讯云开启端口
          • 3.为了安全只允许本机ip访问
    • 2.SpringBoot2整合Redis
        • 1.环境配置
          • 1.创建maven项目
          • 2.pom.xml引入依赖
          • 3.application.yml 配置redis
          • 4.添加Redis的配置类（使用SpringBoot默认的会出些问题关于序列化的）RedisConfig.java
        • 2.测试
          • 1.编写测试的Controller
          • 2.编写主启动类
          • 3.启动测试 [localhost:8080/redisTest/set](http://localhost:8080/redisTest/set)
        • 3.对list进行操作
          • 1.代码
          • 2.结果
        • 4.注意事项
          • 1.先看报错是无法识别的token
          • 2.如果使用redisTemplate进行set会先序列化，然后读取的时候也会反序列化，但是直接在客户端set不会进行序列化，所以在使用redisTemplate进行反序列化的时候就会出现问题
          • 3.解决方式：都使用程序进行操作即可

1.Jedis

1.介绍

image-20240429154127142

2.环境配置
1.创建maven项目

image-20240429154831864

2.pom.xml引入依赖
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.2.0</version>
    </dependency>
3.新建一个包并创建一个文件

image-20240429155409891

3.Jedis远程连接到Redis
1.Redis放到服务器可以连接的前提条件
  • 确认端口开启
  • protected-mode（设置no支持远程访问）
  • 注销bind = 127.0.0.1
  • 最好设置一个密码在requirepass
2.为Redis设置密码
1.编辑配置文件
vim /etc/redis.conf
2.找到 requirepass

image-20240429160256016

3.设置密码为root

image-20240429160319448

4.重启Redis，在shutdown的时候报错，原因是之前连接到了redis的客户端没有关闭，执行下面的指令关闭
redis-cli shutdown nosave
5.然后再重启Redis，此时再次操作Redis就需要密码了

image-20240429163024650

3.编写代码连接Redis
package com.sun.jedis;

import org.junit.Test;
import redis.clients.jedis.Jedis;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 15:53
 * @Version 1.0
 */
public class Jedis_ {

    // 连接redis
    @Test
    public void con() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxx", xxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");
        String ping = jedis.ping();
        System.out.println("ping = " + ping);
        // 关闭命令行连接
        jedis.close();
    }
}

image-20240429163739569

4.key操作
1.代码
    @Test
    public void key() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 设置key
        jedis.set("k1", "v1");
        jedis.set("k2", "v2");
        jedis.set("k3", "v3");

        // 获取所有的key
        Set<String> keys = jedis.keys("*");
        // 遍历输出
        for (String key : keys) {
            System.out.println("key=" + key);
        }

        // 判断key是否存在
        Boolean k1 = jedis.exists("k1");
        System.out.println("k1是否存在？" + k1);

        // 查看key的ttl
        System.out.println("k2的ttl=" + jedis.ttl("k2"));

        // 获取值
        String k3 = jedis.get("k3");
        System.out.println("k3=" + k3);
        jedis.close();

    }
2.结果

image-20240429165247069

5.string操作
1.代码
    @Test
    public void string() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 先清除一下库
        jedis.flushDB();

        // 批量设置string
        jedis.mset("k1", "v1", "k2", "v2", "k3", "v3");

        // 批量获取string
        List<String> mget = jedis.mget("k1", "k2", "k3");
        for (String s : mget) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429165825709

6.list操作
1.代码
    @Test
    public void list() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 先清除一下库
        jedis.flushDB();

        // 向list的左边添加三条记录
        jedis.lpush("key", "v1", "v2", "v3");
        // 显示数据，应该是v3,v2,v1
        List<String> key = jedis.lrange("key", 0, -1);
        for (String s : key) {
            System.out.println(s);
        }
        jedis.close();
    }
}
2.结果

image-20240429170559212

7.set操作
1.代码
    @Test
    public void set() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("root");

        // 先清除一下库
        jedis.flushDB();

        // 向set中添加元素
        jedis.sadd("key", "val1", "val2", "val3");

        // 取出set中的所有值
        Set<String> key = jedis.smembers("key");
        // 遍历输出
        for (String s : key) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429170951539

8.hash操作
1.代码
    @Test
    public void hash() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("xxxxxxx");

        // 先清除一下库
        jedis.flushDB();

        // 向hash中设置值
        Map<String, String> map = new HashMap<String, String>();
        map.put("field1", "value1");
        map.put("field2", "value2");
        map.put("field3", "value3");

        jedis.hset("key", map);

        List<String> hmget = jedis.hmget("key", "field1", "field2", "field3");
        for (String s : hmget) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429205900768

9.zset操作
1.代码
    @Test
    public void zset() {
        // 连接服务器的redis命令行
        Jedis jedis = new Jedis("xxxx", xxxx);
        // 如果redis设置了密码要先进行验证
        jedis.auth("xxxx");

        // 先清除一下库
        jedis.flushDB();

        // 向zset中添加数据
        jedis.zadd("key", 1, "zhangsan");
        jedis.zadd("key", 2, "lisi");
        jedis.zadd("key", 3, "wangwu");
        // 取出数据
        Set<String> key = jedis.zrange("key", 0, -1);
        for (String s : key) {
            System.out.println(s);
        }
        jedis.close();
    }
2.结果

image-20240429210607348

2.由于Redis被攻击了，所以重新配置

1.修改端口为7489

image-20240429200416739

2.设置redis密码

image-20240429195814069

3.使redis支持远程访问

image-20240429200002355

image-20240429200046964

4.重启redis
1.指定配置文件启动redis
/usr/local/bin/redis-server /etc/redis.conf
2.查看是否启动
ps -aux | grep redis

image-20240429200524755

3.指定端口连接redis
/usr/local/bin/redis-cli -p 7489

image-20240429200655032

4.测试密码

image-20240429200728881

5.如果要关闭redis，在命令行关闭redis，输入shutdown
5.开放7489端口
1.宝塔开启端口
systemctl start firewalld && firewall-cmd --permanent --add-port=7489/tcp && firewall-cmd --reload && firewall-cmd --query-port=7489/tcp

image-20240429201337740

2.腾讯云开启端口

image-20240429201549924

3.为了安全只允许本机ip访问

image-20240429205215949

2.SpringBoot2整合Redis

1.环境配置
1.创建maven项目

image-20240429211111679

2.pom.xml引入依赖
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <properties>
        <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <!-- 说 明 : 如 果 这 里 是 spring-boot-start 就 改 成 如 下
            spring-boot-start-web-->
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- spring2.X 集成 redis 所需 common-pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <!--不要带版本号,防止冲突-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.2.2</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
3.application.yml 配置redis
spring:
  redis:
    host: xxxxxx # Redis服务器地址
    port: xxxx# Redis服务器端口
    password: ****** # Redis服务器密码
    database: 0 # 默认数据库为0号
    timeout: 1800000 # 连接超时时间是1800秒
    lettuce:
      pool:
        max-active: 20 # 最大活跃连接数,使用负值表示没有限制
        max-wait: -1 # 最大等待时间,单位为毫秒,使用负值表示没有限制
        max-idle: 10 # 最大空闲连接数
        min-idle: 0 # 最小空闲连接数
4.添加Redis的配置类（使用SpringBoot默认的会出些问题关于序列化的）RedisConfig.java
package com.sun.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
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.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 21:29
 * @Version 1.0
 */
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template =
                new RedisTemplate<>();
        System.out.println("template=>" + template);
        RedisSerializer<String> redisSerializer =
                new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        // key 序列化方式
        template.setKeySerializer(redisSerializer);
        // value 序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // value hashmap 序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer =
                new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        // 解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间 600 秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

image-20240429213253810

2.测试
1.编写测试的Controller
package com.sun.redis.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 21:36
 * @Version 1.0
 */
@RestController
@RequestMapping("/redisTest")
public class TestController {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @RequestMapping("/set")
    public String set() {
        redisTemplate.opsForValue().set("name", "孙显圣");
        return redisTemplate.opsForValue().get("name").toString();
    }
}
2.编写主启动类
package com.sun.redis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/4/29 21:39
 * @Version 1.0
 */
@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class, args);
    }
}
3.启动测试 localhost:8080/redisTest/set

image-20240429214257425

image-20240429214242423

3.对list进行操作
1.代码
    @RequestMapping("/list")
    public String list() {
        // 清除一下库
        redisTemplate.delete("key");
        // 批量添加
        redisTemplate.opsForList().leftPushAll("key", "v1", "v2", "v3");
        // 遍历输出
        List<Object> range = redisTemplate.opsForList().range("key", 0, -1);
        return range.toString();
    }
2.结果

image-20240430084953906

4.注意事项
1.先看报错是无法识别的token

image-20240430085702856

2.如果使用redisTemplate进行set会先序列化，然后读取的时候也会反序列化，但是直接在客户端set不会进行序列化，所以在使用redisTemplate进行反序列化的时候就会出现问题
3.解决方式：都使用程序进行操作即可

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/593918.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

R语言实战——中国职工平均工资的变化分析——相关与回归分析

R语言实战——中国职工平均工资的变化分析——相关与回归分析

链接: R语言学习—1—将数据框中某一列数据改成行名 R语言学习—2—安德鲁斯曲线分析时间序列数据 R语言学习—3—基本操作 R语言学习—4—数据矩阵及R表示 R语言的学习—5—多元数据直观表示 R语言学习—6—多元相关与回归分析 1、源数据 各行业平均工资变化 各地区平均工资…
阅读更多...
常用算法介绍

常用算法介绍

1. 冒泡排序&#xff1a;冒泡排序是一种简单的排序算法&#xff0c;它的基本思想是比较相邻的两个元素&#xff0c;如果顺序错误就交换它们的位置&#xff0c;直到所有元素都按照升序排列。 2. 快速排序&#xff1a;快速排序是一种高效的排序算法&#xff0c;它的基本思想是选取…
阅读更多...
内网端口转发与代理

内网端口转发与代理

思路&#xff1a;渗透的前提是双方能够建立通信。目前无法和win7建立通信&#xff0c;但是拿到了windows2003的权限&#xff0c;所以可以在Windows2003主机上面建立节点&#xff0c;作为跳板机去访问到内网。 目前状态&#xff1a;控制win2003&#xff08;IP&#xff1a;192.1…
阅读更多...
基于JSP的人才公寓管理系统

基于JSP的人才公寓管理系统

目录 背景 技术简介 系统简介 界面预览 背景 随着互联网的广泛推广和应用&#xff0c;人才公寓管理系统在网络技术的推动下迅速进步。该系统的设计初衷是满足住户的实际需求&#xff0c;通过深入了解住户的期望&#xff0c;开发出高度定制化的人才公寓管理系统。利用互联网…
阅读更多...
如何进行Go语言的性能测试和调优？

如何进行Go语言的性能测试和调优？

文章目录 开篇一、性能测试1. 使用标准库中的testing包2. 使用第三方工具 二、性能调优1. 优化算法和数据结构2. 减少不必要的内存分配和垃圾回收3. 并发和并行 结尾 开篇 Go语言以其出色的性能和简洁的语法受到了广大开发者的喜爱。然而&#xff0c;在实际开发中&#xff0c;…
阅读更多...
39.乐理基础-拍号-认识音符

39.乐理基础-拍号-认识音符

拍号是一个分数的形式&#xff0c;如下图篮色的圈圈里的东西&#xff0c;但它的实际意义和分数没什么关系&#xff0c;只是外观上是一个分数的形式 单独拿出拍号&#xff0c;如下图&#xff1a; 然后接下来只要搞懂什么是 Y分音符、一拍、小节就可以了。 音符&#xff1a; 控…
阅读更多...
Java | Leetcode Java题解之第67题二进制求和

Java | Leetcode Java题解之第67题二进制求和

题目&#xff1a; 题解&#xff1a; class Solution {public String addBinary(String a, String b) {StringBuffer ans new StringBuffer();int n Math.max(a.length(), b.length()), carry 0;for (int i 0; i < n; i) {carry i < a.length() ? (a.charAt(a.leng…
阅读更多...
特征提取（Feature Extraction）常见统计特征笔记（三）

特征提取（Feature Extraction）常见统计特征笔记（三）

统计特征是描述数据集中值的一组量&#xff0c;通常用于了解数据的分布、集中趋势和变异程度。常见的统计特征包括均值、中位数、众数、标准差、方差等。下面会详细解释每个统计特征&#xff0c;并给出相应的Python代码。 1、均值&#xff08;Mean&#xff09;&#xff1a;所有…
阅读更多...
分布式存储 Ceph 的演进经验

分布式存储 Ceph 的演进经验

从 2004 年到今天&#xff0c;Ceph 的存储后端一直都在演变&#xff0c;从最开始基于 B 树的 EBOFS 演变到今天的 BlueStore&#xff0c;存储后端已经变得非常成熟&#xff0c;新的存储系统不仅能够提供良好的性能&#xff0c;还有着优异的兼容性。我们在这篇文章中将要简单介绍…
阅读更多...
华为eNSP小型园区网络配置（上）

华为eNSP小型园区网络配置（上）

→跟着大佬学习的b站直通车← 目标1&#xff1a;dhcp分配ip地址 目标2&#xff1a;内网用户访问www.yzy.com sw1 # vlan batch 10 # interface Ethernet0/0/1port link-type accessport default vlan 10 # interface Ethernet0/0/2port link-type trunkport trunk allow-pass…
阅读更多...
【Linux】网络连接配置——nmcli工具配置连接增删改查实例

【Linux】网络连接配置——nmcli工具配置连接增删改查实例

nmcli工具配置连接增删改查实例 &#xff08;一&#xff09;网络连接配置基本项目1.网络接口配置2.主机名配置3.DNS服务器配置 &#xff08;二&#xff09;网络连接配置文件&#xff08;三&#xff09;网络配置方法&#xff08;四&#xff09;nmcli工具配置连接管理1.增2.查3.改…
阅读更多...
prometheus+grafana的安装与部署及优点

prometheus+grafana的安装与部署及优点

一、Prometheus 的优点 1、非常少的外部依赖&#xff0c;安装使用超简单&#xff1b; 2、已经有非常多的系统集成 例如&#xff1a;docker HAProxy Nginx JMX等等&#xff1b; 3、服务自动化发现&#xff1b; 4、直接集成到代码&#xff1b; 5、设计思想是按照分布式、微服…
阅读更多...
GPT-3

GPT-3

论文&#xff1a;Language Models are Few-Shot Learners&#xff08;巨无霸OpenAI GPT3 2020&#xff09; 摘要 最近的工作表明&#xff0c;通过对大量文本进行预训练&#xff0c;然后对特定任务进行微调&#xff0c;在许多NLP任务和基准方面取得了实质性进展。虽然这种方法…
阅读更多...
stm32单片机开发二、定时器-内部时钟中断和外部时钟中断、编码器

stm32单片机开发二、定时器-内部时钟中断和外部时钟中断、编码器

定时器本质就是一个计数器 案例&#xff1a;定时器定时中断 内部时钟中断 Timer_Init(); //定时中断初始化 /*** 函 数&#xff1a;定时中断初始化* 参 数&#xff1a;无* 返 回 值&#xff1a;无*/ void Timer_Init(void) {/*开启时钟*/RCC_APB1PeriphClockCmd(RCC…
阅读更多...
【AI】指定python3.10安装Jupyter Lab

【AI】指定python3.10安装Jupyter Lab

家里电脑 13900K, bash 不识别pythoncmd可以，但是cmd似乎默认是python2.7这个是webrtc构建需要的.python3 则可以识别到但是版本是python3.12*多个版本如何通过制定的python3.10 的pip来安装软件，例如Jupyter Lab安装3.10 C:\Users\zhangbin\AppData\Roaming\Microsoft\Windo…
阅读更多...
网络安全之从原理看懂XSS

网络安全之从原理看懂XSS

01、XSS的原理和分类 跨站脚本攻击XSS(Cross Site Scripting)&#xff0c;为了不和层叠样式表(Cascading Style Sheets&#xff0c;CSS)的缩写混淆 故将跨站脚本攻击缩写为XSS&#xff0c;恶意攻击者往Web页面里插入恶意Script代码&#xff0c;当用户浏览该页面时&#xff0c…
阅读更多...
【附poc】新中新中小学智慧校园信息管理系统存在SQL注入漏洞

【附poc】新中新中小学智慧校园信息管理系统存在SQL注入漏洞

新中新中小学智慧校园信息管理系统介绍&#xff1a;新中新利用云服务技术同时借鉴互联网模式&#xff0c;围绕基础教育信息化、智慧化建设&#xff0c;把线下业务和线上业务结合&#xff0c;为教育主管部门、校园管理者、教师、学生以及家长提供具有教务管理功能的平台化、移动…
阅读更多...
基于TL431基准电压源的可调恒压恒流源的Multisim电路仿真设计

基于TL431基准电压源的可调恒压恒流源的Multisim电路仿真设计

1、线性电源的工作原理 在我们日常应用里&#xff0c;直流电是从市电或电网中的交流电获取的。例如15V直流电压源、24V直流电压源等等。交流电变为直流电的过程大概分为一下几步&#xff1a; 首先&#xff0c;交流电通过变压器降低其电压幅值。接着&#xff0c;经过整流电路进…
阅读更多...
八、Linux进程检测与控制

八、Linux进程检测与控制

章节目标 了解进程和程序的关系了解进程的特点能够使用top动态查看进程信息能够使用ps静态查看进程信息能够使用kill命令给进程发送信号能够调整进程的优先级&#xff08;扩展&#xff09; 引言 在运维的日常工作中&#xff0c;监视系统的运行状况是每天例行的工作&#xff…
阅读更多...
Spring IoCDI （1）

Spring IoCDI （1）

目录 一、IoC & DI入门 1、Spring是什么 &#xff08;1&#xff09;什么是容器&#xff1f; &#xff08;2&#xff09;什么是IoC&#xff1f; 二、IoC介绍 1、传统程序开发 2、解决方案 3、IoC程序开发 4、IoC优势 三、DI介绍 通过前面的学习&#xff0c;我们知…
阅读更多...
最新文章

Copyright @ 2022~2023