redis部署怎么设置内存linux redis部署到linux

转载

mob6454cc77db30 2024-04-20 11:56:00

文章标签 redis部署怎么设置内存linux 线上redis一般安在linux redis spring json 文章分类 Redis 数据库

1，首先先从网上下载redis安装包

2，然后使用FileZilla将压缩包上传至linux中

3，再用putty连接linux ,设置window为Change the size of the fort (可以复制粘贴)

设置Connection的时间(这样就算一段时间不使用putty也不会关闭)

4, cd到你安装redis的目录执行解压命令

tar -zxvf redis-4.0.11.tar.gz ，这时会多一个文件，cd进去进行编译，看到

Hint: It.....说明编译成功了

5，接下来要进行安装 PREFIX后面是你指定的安装目录(一般都在usr目录下)

make install PREFIX=/usr/local/redis ,看到下面的♂说明安装完成了，

6，把把/root/redis-4.0.11/redis.conf复制到/usr/local/redis/bin目录下

cp redis.conf /usr/local/redis/bin/

再cd到/usr/local/redis/bin下会看到这样的目录结构

7，接下来就对redis进行配置，vim redis.conf ,将bind注释到，requirepass是设置密码的

daemonize是是否允许远程登陆的

8,开启redis ./redis-server redis.conf, 再输入ps aux|grep redis查看redis的进程到到下图说明成功开启了。

9，关闭操作有两种一种kill -9 还有一种如下图如何没有设置密码直接./redis-cli

然后shutdown，设置密码的话需要在输入auth 你的密码。(输入quit退出)

到这里redis的安装与配置就已经全部完成了，接下来，就是项目运用了。

项目我分为2个项目，一个是ssm项目，另一个是springboot项目。

1，准备工作，

(1)安装redis客户端RedisDesktopManager(这个在网上有很多，这里就不多说了，有不会的可以私信我)

(2)连接redis

2，编辑applicationContext-redis.xml文件

xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">

3，添加依赖jedis是redis的组件，jackson是用来处理数据的。

redis.clients

jedis

2.9.0

com.fasterxml.jackson.core

jackson-databind

2.8.3

4，引一个jsonUtil工具类，和一个jedisClient的接口，以及其实现类

package com.sesame.utils;

import java.util.List;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.JavaType;

import com.fasterxml.jackson.databind.ObjectMapper;

/**

public class JsonUtils {

// 定义jackson对象

private static final ObjectMapper MAPPER = new ObjectMapper();

/**

* 将对象转换成json字符串。

Title: pojoToJson

Description:

* @param data

* @return

public static String objectToJson(Object data) {

try {

String string = MAPPER.writeValueAsString(data);

return string;

} catch (JsonProcessingException e) {

e.printStackTrace();

}

return null;

}

/**

* 将json结果集转化为对象

* @param jsonData json数据

* @param clazz 对象中的object类型

* @return

public static T jsonToPojo(String jsonData, Class beanType) {

try {

T t = MAPPER.readValue(jsonData, beanType);

return t;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* 将json数据转换成pojo对象list

Title: jsonToList

Description:

* @param jsonData

* @param beanType

* @return

public static List jsonToList(String jsonData, Class beanType) {

JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);

try {

List list = MAPPER.readValue(jsonData, javaType);

return list;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

package com.sesame.redis;

public interface JedisClient {

String set(String key, String value);

String get(String key);

Boolean exists(String key);

Long expire(String key, int seconds);

Long ttl(String key);

Long incr(String key);

Long hset(String key, String field, String value);

String hget(String key, String field);

Long hdel(String key,String... field);//删除hkey

}

package com.sesame.redis;

import org.springframework.beans.factory.annotation.Autowired;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

public class JedisClientPool implements JedisClient {

@Autowired

private JedisPool jedisPool;

@Override

public String set(String key, String value) {

Jedis jedis = jedisPool.getResource();

String result = jedis.set(key, value);

jedis.close();

return result;

}

@Override

public String get(String key) {

Jedis jedis = jedisPool.getResource();

String result = jedis.get(key);

jedis.close();

return result;

}

@Override

public Boolean exists(String key) {

Jedis jedis = jedisPool.getResource();

Boolean result = jedis.exists(key);

jedis.close();

return result;

}

@Override

public Long expire(String key, int seconds) {

Jedis jedis = jedisPool.getResource();

Long result = jedis.expire(key, seconds);

jedis.close();

return result;

}

@Override

public Long ttl(String key) {

Jedis jedis = jedisPool.getResource();

Long result = jedis.ttl(key);

jedis.close();

return result;

}

@Override

public Long incr(String key) {

Jedis jedis = jedisPool.getResource();

Long result = jedis.incr(key);

jedis.close();

return result;

}

@Override

public Long hset(String key, String field, String value) {

Jedis jedis = jedisPool.getResource();

Long result = jedis.hset(key, field, value);

jedis.close();

return result;

}

@Override

public String hget(String key, String field) {

Jedis jedis = jedisPool.getResource();

String result = jedis.hget(key, field);

jedis.close();

return result;

}

@Override

public Long hdel(String key, String... field) {

Jedis jedis = jedisPool.getResource();

Long hdel = jedis.hdel(key, field);

jedis.close();

return hdel;

}

5，接下来就可以编写代码了，定义一个Student的表

CREATE TABLE `student` (

`id` int(11) NOT NULL AUTO_INCREMENT COMMENT ' 主键 ',

`name` varchar(50) DEFAULT NULL COMMENT ' 名字 ',

PRIMARY KEY (`id`) USING BTREE

) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='学生表'

6，同样需要在项目中定义一个Student的POJO

package com.sesame.wx.liyuan.bean;

import java.io.Serializable;

public class Student implements Serializable{

private static final long serialVersionUID = 1L;

private Integer id;

private String name;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

7，Dao层

public Student getStudent(Integer stuId);

select id, name from student where id = #{stuId}

8，Service层

public Student getStudent(Integer stuId) {

try {

String jsonstr = client.get("CONTENT_KEY"+stuId);//从redis数据库中获取内容分类下的所有的内容。

//如果存在，说明有缓存

if(StringUtil.isNotEmpty(jsonstr)){

System.out.println("这里有缓存啦！！！！！");

return JsonUtils.jsonToPojo(jsonstr, Student.class); //将json数据转为POJO对象

}

} catch (Exception e1) {

e1.printStackTrace();

}

Student student = liyuanDao.getStudent(stuId);

try {

System.out.println("没有缓存！！！！！！");

client.set("CONTENT_KEY"+stuId, JsonUtils.objectToJson(student)); // 将数据转为json数据传入redis数据库

client.expire("CONTENT_KEY"+stuId, 100); // 设置缓存时间,单位为秒

} catch (Exception e) {

e.printStackTrace();

}

return student;

}

9，Controller层

@RequestMapping("/getStudent")

@ResponseBody

public Map getStudent(Integer stuId) {

Map resMap = new HashMap();

Student student = liyuanSercice.getStudent(stuId);

resMap.put("student", student);

return resMap;

}

当看到下面的图片，说明缓存成功了。TTL是你设置的缓存时间

上面就是ssm使用redis的全部过程了，接下来就介绍springboot项目使用redis，这里还使用了cache插件来整合redis看起来代码更简洁一点。

1，首先创建user表，(我们不在是学生了，变成用户了=-=)

CREATE TABLE `user` (

`id` int(11) NOT NULL AUTO_INCREMENT COMMENT ' 主键 ',

`name` varchar(50) DEFAULT NULL COMMENT ' 名字 ',

PRIMARY KEY (`id`) USING BTREE

) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='用户表'

2，配置文件

yml

spring:

redis:

host: 192.168.92.128

port: 6379

password: 123456

cache:

type: redis

cache:

expire-time: 180 // 设置过期时间

CONFIG

package com.walklake.log.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.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;

/**

* 必须继承CachingConfigurerSupport，不然此类中生成的Bean不会生效(没有替换掉默认生成的，只是一个普通的bean)

* springboot默认生成的缓存管理器和redisTemplate支持的类型很有限，根本不满足我们的需求，会抛出如下异常：

* org.springframework.cache.interceptor.SimpleKey cannot be cast to java.lang.String

@Configuration

@EnableCaching

public class SpringCacheRedisConfig extends CachingConfigurerSupport {

@Value("${cache.expire-time:180}")

private int expireTime;

// 配置key生成器，作用于缓存管理器管理的所有缓存

// 如果缓存注解(@Cacheable、@CacheEvict等)中指定key属性，那么会覆盖此key生成器

@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();

};

}

// 缓存管理器管理的缓存都需要有对应的缓存空间，否则抛异常：No cache could be resolved for 'Builder...

@Bean

public CacheManager cacheManager(RedisTemplate redisTemplate) {

RedisCacheManager rcm = new RedisCacheManager(redisTemplate);

rcm.setDefaultExpiration(expireTime); //设置缓存管理器管理的缓存的过期时间, 单位：秒

return rcm;

}

@Bean

public RedisTemplate 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;

}

3，接下来就是项目了，先在pom文件添加依赖

org.springframework.boot

spring-boot-starter-data-redis

org.springframework.boot

spring-boot-starter-cache

4，创建POJO

package com.walklake.log.entity;

import java.io.Serializable;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.Table;

import lombok.Data;

@Data

@Entity

@Table(name="user")

public class User implements Serializable {

private static final long serialVersionUID = 1L;

@Id

@GeneratedValue(strategy = GenerationType.AUTO)

private Integer id;

private String name;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

5，Dao层(这里springboot使用的是spring data，非常好用，有时间我写一个spring data的文章)

package com.walklake.log.dao;

import org.springframework.data.repository.CrudRepository;

import com.walklake.log.entity.User;

public interface UserDAO extends CrudRepository {

User findById(Integer id);

}

6，Service(cache插件 @Cacheable为查询，第一次走代码，第二次走redis,@CachePut为更新，每次都会走代码，并将返回值保存到redis数据库中，所以一定要有返回值，

不然会保存null，@CacheEvict为删除，@Caching为组合可以任意搭配前面的注解

package com.walklake.log.service;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.annotation.CacheEvict;

import org.springframework.cache.annotation.CachePut;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.cache.annotation.Caching;

import org.springframework.stereotype.Service;

import com.walklake.log.dao.UserDAO;

import com.walklake.log.entity.User;

@Service

public class UserService {

public static final String CACHE_KEY = "myCache";

@Autowired

private UserDAO userDAO;

public void saveUser(String name) {

User user = new User();

user.setName(name);

userDAO.save(user);

}

@CacheEvict(value="user",key ="'myCache'+#id")

public void deleteUser(Integer id) {

userDAO.delete(id);

}

@CachePut(value = "user",key ="'myCache'+#user.getId()")

public User updateUser(User user) {

return userDAO.save(user);

}

@Cacheable(value="user",key ="'myCache'+#id")

public User searchUser(Integer id) {

return userDAO.findById(id);

}

@Caching(cacheable = {@Cacheable(value="user",key ="'myCache'+#id")},

put = {@CachePut(value = "user",key ="'myCache'+#user.getId()")},

evict = {@CacheEvict(value="user",key ="'myCache'+#id")}

)

public User updateAndSelect(User user) {

userDAO.delete(user.getId());

return userDAO.save(user);

}

7，Controller层

package com.walklake.log.controller;

import java.util.HashMap;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import com.walklake.log.entity.User;

import com.walklake.log.service.UserService;

* @Author:zjd

* @Date:2019/5/13 15:29

* @Detail:记录签到数据

@RestController

@RequestMapping("/user")

public class UserController {

@Autowired

private UserService userService;

@GetMapping("/save")

@SuppressWarnings("rawtypes")

public Map save(String name) {

Map resMap = new HashMap();

try {

userService.saveUser(name);

resMap.put("result", "保存成功");

} catch (Exception e) {

e.printStackTrace();

resMap.put("result", "保存失败");

}

return resMap;

}

@GetMapping("/delete")

@SuppressWarnings("rawtypes")

public Map delete(Integer id) {

Map resMap = new HashMap();

try {

userService.deleteUser(id);

resMap.put("result", "删除成功");

} catch (Exception e) {

e.printStackTrace();

resMap.put("result", "删除失败");

}

return resMap;

}

@GetMapping("/update")

@SuppressWarnings("rawtypes")

public Map update(Integer id, String name) {

Map resMap = new HashMap();

User user = new User();

user.setId(id);

user.setName(name);

try {

userService.updateUser(user);

resMap.put("result", "更新成功");

} catch (Exception e) {

e.printStackTrace();

resMap.put("result", "更新失败");

}

return resMap;

}

@GetMapping("/search")

@SuppressWarnings("rawtypes")

public Map search(Integer id) {

Map resMap = new HashMap();

try {

User user = userService.searchUser(id);

resMap.put("result", user);

} catch (Exception e) {

e.printStackTrace();

resMap.put("result", "查询失败");

}

return resMap;

}

@GetMapping("/updateAndSelect")

@SuppressWarnings("rawtypes")

public Map updateAndSelect(Integer id, String name) {

Map resMap = new HashMap();

User user = new User();

user.setId(id);

user.setName(name);

try {

userService.updateUser(user);

resMap.put("result", "更新成功");

} catch (Exception e) {

e.printStackTrace();

resMap.put("result", "更新失败");

}

return resMap;

}

8，接下来就进行测试了

(1)首先测试查询，看到下面的图片说明成功了

(2)然后测试更新，看到下面的图片说明成功了

(3)测试删除，看到下面的图片说明成功了

(4)最后测试组合组件，看到下面的图片说明成功了

全部搞定！！！

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：treemap倒序打印 treemap如何排序

下一篇：arco design 打包反编译 apkdb反编译教程

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

redis部署怎么设置内存linux redis部署到linux

redis部署怎么设置内存linux redis部署到linux

51CTO博客