Bagaimana untuk mengkonfigurasi dan menggunakan redis-Redis-php.cn

Spring-data-redis ialah bahagian sokongan untuk redis dalam modul spring-data, yang dirujuk sebagai "SDR". Ia menyediakan tahap enkapsulasi tinggi berdasarkan API klien jedis dan integrasi dengan bekas spring , pelanggan jedis sudah cukup Mudah dan ringan, spring-data-redis disyaki "terlalu reka bentuk".
Pelanggan jedis mempunyai kelemahan berikut dalam pelaksanaan pengaturcaraan:
1) Pengurusan sambungan tidak mempunyai automasi, dan reka bentuk sambungan-pool tidak mempunyai sokongan kontena yang diperlukan.
2) Operasi data perlu memberi perhatian kepada "bersiri"/"deserialisasi", kerana jenis data yang diterima oleh API klien jedis ialah rentetan dan bait, dan pengendalian data berstruktur (json, xml, pojo) memerlukan sokongan tambahan .
3) Operasi transaksi adalah berkod keras semata-mata
4) Fungsi pub/sub tidak mempunyai sokongan corak reka bentuk yang diperlukan, yang memerlukan terlalu banyak perhatian untuk pembangun.
1. Senario penggunaan Redis
Redis ialah pangkalan data Nilai Kunci jenis log sumber terbuka yang ditulis dalam bahasa ANSI C, menyokong rangkaian, boleh berasaskan memori dan berterusan serta menyediakan API dalam berbilang bahasa.
Kita semua tahu bahawa dalam aplikasi harian, kesesakan pangkalan data adalah yang paling mungkin berlaku. Disebabkan oleh jumlah data yang banyak dan pertanyaan yang kerap, prestasi projek semakin rendah dan lebih rendah disebabkan oleh had prestasi IO cakera.
Pada masa ini, rangka kerja caching berasaskan memori boleh menyelesaikan banyak masalah kita. Contohnya Memcache, Redis, dll. Meletakkan beberapa data yang kerap digunakan ke dalam cache untuk membaca sangat mengurangkan beban pada pangkalan data. Prestasi sistem yang lebih baik. Malah, perkara yang sama berlaku untuk cache tahap kedua hibernate dan Mybatis. Gunakan kelajuan memori membaca dan menulis berkelajuan tinggi untuk menyelesaikan kesesakan cakera keras.

2. Konfigurasikan dan gunakan redis

Konfigurasi dalam applicationContext-dao.xml adalah seperti berikut:

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mongo="http://www.springframework.org/schema/data/mongo"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/data/mongo
http://www.springframework.org/schema/data/mongo/spring-mongo.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<

database.properties配置文件如下：

redis.maxIdle=10
redis.maxActive=20
redis.maxWait=10000
redis.testOnBorrow=true
redis.host=192.168.1.76
redis.port=6379
redis.pass=password1

spring-data-redis提供了多种serializer策略，这对使用jedis的开发者言叐供了多种serializer策略，这对使用jedis的，开发者耶便捷。 sdr提供了4种内置的serializer：

JdkSerializationRedisSerializer：使用JDK的序列化手段(boleh bersiri接口，ObjectInputStrean，ObjectOutputStream)，数据以字节流存储，POJO对是用家身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列，是目前最常用的序列化策略。
Stringredisserializer: 字符串字符串编码, 数据以 string 存储, kekunci 或者 nilai 为字符串的场景, 根据根据的的 charset 对数据数据字节字节序列编码成成成成是charset)”的直接封装。是最轻量级和高效的策略。
JacksonJsonRedisSerializer: storan format json, alat jackson-json menyediakan keupayaan penukaran antara javabean dan json Ia boleh mensirikan kejadian pojo ke dalam format json dan menyimpannya dalam redis, atau menukar data format json kepada kejadian pojo. Oleh kerana alat Jackson perlu menyatakan secara eksplisit jenis Kelas semasa mensiri dan menyahsiri, strategi ini lebih rumit sedikit untuk dirangkumkan. [Memerlukan sokongan alat jackson-mapper-asl]
OxmSerializer: storan format xml, menyediakan keupayaan untuk menukar javabeans kepada xml yang tersedia pada masa ini sokongan tiga pihak termasuk jaxb, apache-xmlbeans data yang disimpan dalam redis akan menjadi alat xml. Walau bagaimanapun, menggunakan strategi ini akan menjadikan pengaturcaraan lebih sukar dan paling berkesan ia tidak disyorkan. [Memerlukan sokongan modul spring-oxm]

Antaranya, JdkSerializationRedisSerializer dan StringRedisSerializer ialah strategi bersiri yang paling asas Antaranya, "JacksonJsonRedisSerializer" dan "OxmSerializer" adalah berdasarkan storan rentetan, jadi ia lebih bersiri "maju" (akhirnya menggunakan penghuraian rentetan dan membina objek java). JdkSerializationRedisSerializer dan StringRedisSerializer ialah strategi paling asas untuk "serialisasi dan serialisasi". JacksonJsonRedisSerializer" dan "OxmSerializer" secara langsung pada masa reka bentuk, kerana sama ada ia json atau xml, mereka sendiri masih String. Jika data anda perlu dihuraikan oleh alat pihak ketiga, data harus menggunakan StringRedisSerializer dan bukannya JdkSerializationRedisSerializer.

4 jenis serializers perlu diisytiharkan dalam RedisTemplate, lalai ialah "JdkSerializationRedisSerializer":

1) keySerializer: Untuk operasi K-V biasa, strategi bersiri yang diguna pakai oleh kunci
2) valueSerializer: Strategi bersiri yang diguna pakai mengikut nilai
3) hashKeySerializer: Dalam struktur data cincang, strategi bersiri bagi kunci cincang
4) hashValueSerializer: strategi siri nilai hash

Dalam apa jua keadaan, adalah disyorkan untuk menggunakan StringRedisSerializer untuk kunci/hashKey.

spring-data-redis menyediakan fungsi berikut untuk jedis:

1 Pengurusan, menyediakan kelas "RedisTemplate" yang sangat lengkap

2. Mengelaskan dan merangkum sejumlah besar API dalam klien jedis, dan merangkum jenis operasi yang sama ke dalam antara muka operasi

ValueOperations: Operasi K-V yang ringkas
SetOperations: set jenis operasi data
ZSetOperations: operasi data jenis zset
HashOperations: Operasi data untuk jenis peta
ListOperations: Operasi data untuk jenis senarai

3. Menyediakan API operasi mudah "terikat" (mengikat) untuk kekunci Anda boleh merangkum kunci yang ditentukan melalui terikat, dan kemudian melakukan satu siri operasi tanpa "jelas" menyatakan kunci itu sekali lagi, iaitu, BoundKeyOperations:

<.>

BoundValueOperations
BoundSetOperations
BoundListOperations
BoundSetOperations
BoundHashOperations

3. Penggunaan RedisTemplate

Sebagai kelas templat, kelas ini menyediakan banyak API untuk menggunakan redis dengan cepat tanpa perlu mengekalkan sambungan dan transaksi sendiri. Pada mulanya, BaseRedisDao yang saya cipta diwarisi daripada kelas ini. Kelebihan warisan ialah dalam setiap Dao saya, saya boleh mengawal penyeri bersiri secara bebas dan sama ada saya memerlukan urus niaga saya tidak perlu memahami perkara ini terlebih dahulu, cuma ikut kaedah konfigurasi semasa saya. Templat menyediakan satu siri operasi, seperti valueOperation, HashOperation, ListOperation, SetOperation, dsb., yang digunakan untuk mengendalikan Redis daripada jenis data yang berbeza. Selain itu, RedisTemplate juga menyediakan *OperationsEditor yang sepadan, yang digunakan untuk menyuntik terus Operasi yang sepadan melalui RedisTemplate.
Kod teras:

pakej com.npf.dao.impl;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.annotation.Resource;
import org.springframework.beans.factory.anotation.Autowired; import org.springframework.data.redis.core.HashOperations; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Repository;
import com.npf.dao.StudentDao;
import com.npf.model.Pelajar;
@Repositori
kelas awam StudentDaoImpl melaksanakan StudentDao{
@Autowired
peribadi RedisTemplate redisTemplate;
@Resource(name="redisTemplate")
HashOperations opsForHash;
String akhir statik awam PELAJAR = "pelajar";
@Override
public void save(Pelajar pelajar) {
opsForHash.put(STUDENT, student.getId(), student);
}
@Override
awam Pencarian Pelajar(id String) {
Pelajar pelajar = opsForHash.get(STUDENT, id);
pelajar kembali;
}
@Override
public void delete(String id) {
opsForHash.delete(STUDENT, id);
}
@Override
kemas kini public void (Pelajar pelajar) {
opsForHash.put(STUDENT, student.getId(), student);
}
@Override
awam Senarai findAll() {
Peta entri = opsForHash.entry(STUDENT);
Senaraikan stuList = new ArrayList();
untuk(Entry entry : entry.entrySet()){
stuList.add(entry.getValue());
}
kembalikan stuList;
}
}

控制层代码如下：

pakej com.npf.controller;
import java.util.List;
import java.util.UUID;
import org.springframework.beans.factory.anotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.npf.model.Pelajar;
import com.npf.service.StudentService;
@Pengawal
Pengawal Pelajar kelas awam {
@Autowired
private StudentService studentService;
@RequestMapping("/pelajar/simpan")
awam String simpanPelajar(Pelajar Pelajar){
String id = UUID.randomUUID().toString();
System.out.println(id);
student.setId(id);
studentService.save(pelajar);
return "redirect:/student/find/all";
}
@RequestMapping("/pelajar/kemas kini")
public String updatePelajar(Pelajar pelajar){
studentService.update(pelajar);
return "redirect:/student/find/all";
}
@RequestMapping("/pelajar/ke/simpan/borang")
awam String toSaveStudentForm(){
pulangkan "simpan";
}
@RequestMapping("/pelajar/padam")
awam String deleteStudent(@RequestParam("id") String id){
studentService.delete(id);
return "redirect:/student/find/all";
}
@RequestMapping("/pelajar/ke/kemas kini/borang")
awam String toUpdateStudentForm(@RequestParam("id") String id,Model model){
Student stu = studentService.find(id);
model.addAttribute("stu", stu);
kembalikan "kemas kini";
}
@RequestMapping("/pelajar/cari/semua")
awam String findPelajar(Model model){
Senaraikan stuList = studentService.findAll();
model.addAttribute("stuList", stuList);
kembalikan "senarai";
}
}

Atas ialah kandungan terperinci Bagaimana untuk mengkonfigurasi dan menggunakan redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!