栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

《Spring实战》

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

《Spring实战》

《Spring实战》 第一部分、spring核心 Bean的生命周期

图:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4kbbfrX-1653878168424)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405120759212.png)]

步骤讲解:

1.Spring对bean进行实例化;

2.Spring将值和bean的引用注入到bean对应的属性中;

3.如果bean实现了BeanNameAware接口,Spring将bean的ID传递给setBean-Name()方法;

4.如果bean实现了BeanFactoryAware接口,Spring将调用setBeanFactory()方法,将BeanFactory容器实例传入;

5.如果bean实现了ApplicationContextAware接口,Spring将调用setApplicationContext()方法,将bean所在的应用上下文的引用传入进来;

6.如果bean实现了BeanPostProcessor接口,Spring将调用它们的post-ProcessBeforeInitialization()方法;

7.如果bean实现了InitializingBean接口,Spring将调用它们的after-PropertiesSet()方法。类似地,如果bean使用init-method声明了初始化方法,该方法也会被调用;

8.如果bean实现了BeanPostProcessor接口,Spring将调用它们的post-ProcessAfterInitialization()方法;

9.此时,bean已经准备就绪,可以被应用程序使用了,它们将一直驻留在应用上下文中,直到该应用上下文被销毁;

10.如果bean实现了DisposableBean接口,Spring将调用它的destroy()接口方法。同样,如果bean使用destroy-method声明了销毁方法,该方法也会被调用

装配Bean与高级装配 自动化装配Bean

Spring从两个角度来实现自动化装配:

组件扫描(component scanning):Spring会自动发现应用上下文中所创建的bean。

自动装配(autowiring):Spring自动满足bean之间的依赖。组件扫描和自动装配组合在一起就能发挥出强大的威力,它们能够将你的显式配置降低到最少。

@Component:放在类上Spring会为其创建一个Bean类

@ComponentScan:能够在Spring中启动组件扫描

@Configuration:表明其是一个配置类

@Autowired: 实现自动注入、可以用在构造器上、Setter方法上。 我们可以将其values中的require设置为false,如果没有匹配的Bean、Spring会将其置为空的状态。

@Qualifier注解配合@Autowired是使用限定符的主要方式,例如一个接口被多个实现类实现,可以使用该注解来限定改注入谁

tips:@Autowired是Spring特有的注解 通过by-Type来实现。与其功能相同的还有@Resource(by-name)、@Inject等方式实现注入

程序清单:

package com.Manage.practise;
//创建了一个CD接口
public interface CD {
    void play();
}
package com.Manage.practise;
//带有component注解的CD实现类
@Component
public class CDimp implements CD {
    private String title = "周杰伦";
    private String content = "蒲公英的约定";
    @Override
    public void play() {
        System.out.println("我正在播出的是" + title + content);
    }
}
package com.Manage.practise;

import org.springframework.context.annotation.ComponentScan;

@Configuration
@ComponentScan //改注解启动了组件扫描
public class CDconfig {
}
//如果没有其他配置,@ComponentScan默认会扫描与配置类相同的包 //如果是SpringBoot项目则不需要(这里后续会讲解到)

测试代码

package com.example.management;

//测试代码  这里使用到了hutool工具
import cn.hutool.core.lang.Assert;
import com.Manage.ManageApplication;
import com.Manage.practise.CD;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest(classes = ManageApplication.class)
class ManagementApplicationTests {

    @Autowired
    private CD cd;
    
    @Test
    void contextLoads() {
        Assert.notNull(cd,"空");
    }
}

测试结果发现为空。说明cd的值并不是空。即@Component成功将其注册成为Bean

通过java代码显示注册Bean

例子:

package com.Manage.practise2;

import com.Manage.practise.CD;
import com.Manage.practise.CDimp;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BeanConfiguration {
    @Bean //通过@Bean方式注册为Bean
    public CD cdsetter(){
        return new CDimp();
    }
}
通过XML方式

这里很少用,不做过多笔记。

高级装配 Bean的作用域

Spring应用上下文中所有bean都是作为以单例(singleton)的形式创建的。也就是说,不管给定的一个bean被注入到其他bean多少次,每次所注入的都是同一个实例

Spring定义了多种作用域,可以基于这些作用域创建bean,包括:

单例(Singleton):在整个应用中,只创建bean的一个实例。

原型(Prototype):每次注入或者通过Spring应用上下文获取的时候,都会创建一个新的bean实例。

会话(Session):在Web应用中,为每个会话创建一个bean实例。

请求(Rquest):在Web应用中,为每个请求创建一个bean实例。

单例是Bean的默认创建方式,对于易变的类型,这并不合适。如需选择其他类型则需要使用@Scope注解

@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)//指定为原型模式
面向切面编程 什么是面向切面编程?

切面提供了取代继承和委托的另一种可选方案,而且在很多场景下更清晰简洁。在使用面向切面编程时,我们仍然在一个地方定义通用功能,但是可以通过声明的方式定义这个功能要以何种方式在何处应用,而无需修改受影响的类。横切关注点可以被模块化为特殊的类,这些类被称为切面(aspect)

Spring会在运行时通知对象:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qilMVen2-1653878168592)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405143759550.png)]

创建切点和使用注解创建切面

在具体介绍之前我们先来介绍一些前置知识

通知:定义了切面是什么以及何时使用。除了描述切面要完成的工作,通知还解决了何时执行这个工作的问题。它应该应用在某个方法被调用之前?之后?之前和之后都调用?还是只在方法抛出异常时调用?

Spring切面可以应用5种类型的通知:前置通知(Before):在目标方法被调用之前调用通知功能;后置通知(After):在目标方法完成之后调用通知,此时不会关心方法的输出是什么;返回通知(After-returning):在目标方法成功执行之后调用通知;异常通知(After-throwing):在目标方法抛出异常后调用通知;环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为。

切点:如果说通知定义了切面的“什么”和“何时”的话,那么切点就定义了“何处”。切点的定义会匹配通知所要织入的一个或多个连接点

切面:切面是通知和切点的结合。通知和切点共同定义了切面的全部内容——它是什么,在何时和何处完成其功能

编写切点:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mThLQcVq-1653878168603)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405144830199.png)]

在切点中选择Bean:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZmaUIeN9-1653878168613)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405144920857.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gO6HEuTJ-1653878168624)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405144932700.png)]

//定义切点
public interface Perform {
    void play();
}
//切点实现类
package com.Manage.practise2;

import org.springframework.stereotype.Component;

@Component
public class Performence implements Perform{
    @Override
    public void play() {
        System.out.println("Play show");
    }
}	
//定义切面
package com.Manage.practise2;

import org.aspectj.lang.annotation.*;

@Component 
@Aspect
public class Audience{
   
    @Before("execution(* practise2.perform.play(..))")
    public void silence(){
        System.out.println("Before");
    }

    @Before("execution(* practise2.perform.play(..))")
    public void after(){
        System.out.println("take a seat");
    }

    @AfterReturning("execution(* practise2.perform.play(..))")
    public void appluse(){
        System.out.println("Clap,clap,clap");
    }

    @AfterThrowing("execution(* practise2.perform.play(..))")
    public void fail(){
        System.out.println("AAAAA");
    }
}

//测试

package com.example.management;

import cn.hutool.core.lang.Assert;
import com.Manage.ManageApplication;
import com.Manage.practise.CD;
import com.Manage.practise2.Audience;
import com.Manage.practise2.Perform;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)   //注意这里必须要使用这个注解同时也需要导入相对应依赖
@SpringBootTest(classes = ManageApplication.class)
class ManagementApplicationTests {

    @Autowired
    private Perform perform;

    @Test
    void contextLoads() {
        perform.play();
    }
}

测试结果:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HJnUmQjy-1653878168633)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405152626820.png)]

这里发现Before在 take a seat前面执行。

AOP执行顺序: AOP ->Around - >before -> method ->after -> afterthrow

可以通过Order注解来指定执行顺序里面值越大执行顺序越前

//这里将第一个Before的方法名的String大于第二个后执行顺序就变了。

结果:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p4g50Pwd-1653878168642)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405155209308.png)]

各个注解详解:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Afu5A6Z-1653878168652)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405145638212.png)]

使用@Pointcut注解声明频繁使用的切点表达式:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SMGeBlaA-1653878168669)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405145846377.png)]

//增强之后

package com.Manage.practise2;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Audience{
	//自定义切点
    @Pointcut("execution(* com.Manage.practise2.Perform.play(..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void silence(){
        System.out.println("Before");
    }

    @Before("pointcut()")
    public void after(){
        System.out.println("take a seat");
    }

    @AfterReturning("pointcut()")
    public void appluse(){
        System.out.println("Clap,clap,clap");
    }

    @AfterThrowing("execution(* com.Manage.practise2.Perform.play(..))")
    public void fail(){
        System.out.println("AAAAA");
    }
}

创建环绕通知

package com.Manage.practise2;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


@Component
@Aspect
public class Audience{
    @Pointcut("execution(* com.Manage.practise2.Perform.play(..))")
    public void pointcut(){}

    @Around("pointcut()")
    public void watchPerformance(ProceedingJoinPoint joinPoint){
        try {
            System.out.println("silence cellphone");
            System.out.println("Take a seat");
            joinPoint.proceed();
            System.out.println("Clap,Clap,Clap");
        } catch (Throwable e) {
            System.out.println("Demanding a refund");
        }

    }
}

结果:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q2LZne3V-1653878168677)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405160020781.png)]

第二部分、Web中的Spring 追踪SpringMVC请求

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l5XQ3SqW-1653878168696)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220405160312585.png)]

讲解:

1.Spring MVC所有的请求都会通过一个前端控制器(front controller)Servlet。而这个前端控制器就是DispatcherServlet

2.DispatcherServlet的任务就是将请求发送给SpringMVC控制器。DispatcherServlet需要知道应该将请求发送给哪个控制器。所以DispatcherServlet以会查询一个或多个处理器映射(handler mapping),来确定请求的下一站在哪里

3.一旦选择了合适的控制器,DispatcherServlet会将请求发送给选中的控制器。到了控制器,请求会卸下其负载(用户提交的信息)并耐心等待控制器处理这些信息

4.控制器在完成逻辑处理后,通常会产生一些信息,这些信息需要返回给用户并在浏览器上显示。这些信息被称为模型(model)控制器所做的最后一件事就是将模型数据打包,并且标示出用于渲染输出的视图名。它接下来会将请求连同模型和视图名发送回DispatcherServlet

5.DispatcherServlet将会使用视图解析器(view resolver)来将逻辑视图名匹配为一个特定的视图实现

6.既然DispatcherServlet已经知道由哪个视图渲染结果,那请求的任务基本上也就完成了。它的最后一站是视图的实现

7.响应给网页。

控制器、请求的输入、处理表单

定义一个简单的控制器

package com.Manage.practise3;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller			//声明为一个控制器
public class spitter {
    @RequestMapping(value ="/" , method = RequestMethod.GET)  //处理对“/”的GET请求
    public String home(){
        return "home";		//视图名为home
    }
}

我们也可以将控制器映射到 ‘/’ 上在类上加入@RequestMapping

package com.Manage.practise3;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping(value ="/" , method = RequestMethod.GET) 	//将请求映射到‘/’上
public class spitter {
    public String home(){
        return "home";
    }
}

package com.Manage.practise3;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping({"/" , "/homepage"})		//将‘/’映射到对应homepage的请求
public class spitter {
    public String home(){
        return "home";
    }
}

校验表单

从Spring 3.0开始,在Spring MVC中提供了对Java校验API的支持。在Spring MVC中要使用Java校验API的话,并不需要什么额外的配置。只要保证在类路径下包含这个Java API的实现即可,比如Hibernate Validator。

Java校验API定义了多个注解,这些注解可以放到属性上,从而限制这些属性的值。所有的注解都位于javax.validation.constraints包中。表5.1列出了这些校验注解。详细查看

SpringMVC高级技术 控制multipart形式数据(上传)

这里给出自己的测试代码(基于SpringBoot配置的)

package com.Manage.practise3;


import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;


@Controller
public class UploadController {
    @RequestMapping(value = "/load" , method = RequestMethod.POST)
    @ResponseBody
    public String upload(@RequestPart MultipartFile file){
        String filename = file.getResource().getFilename();	//获取上传的文件名字 例:如果上传为XXX.xxx 则可以保存相对应的内容
        System.out.println(filename);
        File obj = new File("E:\Project\"+filename);		//设置存储路径 例:这里为EProjectXXX.xxx
        try {
            file.transferTo(obj);						//IO流转换
        } catch (IOException e) {
            e.printStackTrace();
        }
        String path = obj.getAbsolutePath();			
        return "上传到"+path;
    }
}

SpringBoot yml文件配置

Spring:
    servlet:
        multipart:
          max-request-size: 100MB		
          max-file-size: 100MB			//分别设置最大请求与文件最大大小
      
server:
  servlet:
    encoding:
      charset: utf-8				//设置编码格式为UTF-8
      enabled: true
      force: true

SpringMVC配置

package com.Manage.practise3;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.multipart.MultipartFile;

import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;


@Configuration
public class UploadConfig {
    @Bean("multipartResolver")				//通过@Bean的方式来交给Spring容器管理
    public MultipartResolver resolver(){
        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
        resolver.setMaxUploadSize(1024*1024*100);	//设置最大容量
        resolver.setDefaultEncoding("UTF-8");		//编码设置
        return resolver;
    }
}

这里给出前端简单的代码




    Upload a file please


Please upload a file

SpringMVC处理异常

Spring提供了多种方式将异常转换为响应:

特定的Spring异常将会自动映射为指定的HTTP状态码;

异常上可以添加@ResponseStatus注解,从而将其映射为某一个HTTP状态码;

在方法上可以添加@ExceptionHandler注解,使其用来处理异常

关于更多的请查看这两个 SpringMVC全局处理异常、SpringMVC中的统一异常处理

保护Web安全—Spring-Security

编写简单的安全性配置

package com.Manage.config.webSecurityConfig;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity //启用web安全性
public class SecurityConfig extends WebSecurityConfigurerAdapter {

}
//它同时还配置了一个bean,在使用Spring表单绑定标签库来定义表单时,这个bean会自动添加一个隐藏的跨站请求伪造(cross-site requestforgery,CSRF)token输入域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TU4450mz-1653878168706)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220406161826551.png)]

目前我们的程序中是没有重写上述任意一个configure,这就说明了为什么应用现在是被锁定的。尽管对于我们的需求来讲默认的Filter链是不错的,但是默认的configure(HttpSecurity)实际上等同于如下所示:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UwZvGitQ-1653878168715)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220406162017337.png)]

这个简单的默认配置指定了该如何保护HTTP请求,以及客户端认证用户的方案。通过调用authorizeRequests()和anyRequest().authenticated()就会要求所有进入应用的HTTP请求都要进行认证。它也配置Spring Security支持基于表单的登录以及HTTP Basic方式的认证。

同时,因为我们没有重载configure(AuthenticationManagerBuilder)方法,所以没有用户存储支撑认证过程。没有用户存储,实际上就等于没有用户。

所以,在这里所有的请求都需要认证,但是没有人能够登录成功

为了Spring Security能够满足我们应用的需求,我门还需要在添加一些配置,例如:

配置用户存储;

指定哪些请求需要认证,哪些请求不需要认证,以及所需要的权限;

提供一个自定义的登录页面,替代原来简单的默认登录页。

除了Spring Security的这些功能,我们可能还希望基于安全限制,有选择性地在Web视图上显示特定的内容。但首先,我们看一下如何在认证的过程中配置访问用户数据的服务

1.验证用户

使用基础内存的用户存储

@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //在内存中创建了两个账号
        auth
                .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER").and()
                .withUser("admin").password("password").roles("ADMIN");
    }

配置自定义的用户服务

假设我们需要认证的用户存储在非关系型数据库中,如Mongo或Neo4j,在这种情况下,我们需要提供一个自定义的UserDetailsService接口实现

//自定义从数据库验证
	@Autowired
    private UserMapper mapper;
//SpringSecurity校验
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //利用DAO层查询user
        User user = this.finduserByname(username);
        if(user == null) throw new UsernameNotFoundException("没找到改用户");
        //返回验证信息
        return org.springframework.security.core.userdetails.User
                .withUsername(user.getUsername())
                .password(user.getPassword())
                .roles(user.getRole())
                .build();
    }
 //重写三个configure其中一个
 @Autowired
    AuthServiceImp authService;
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //密文比较
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        auth
                .userDetailsService(authService)
                .passwordEncoder(encoder);
    }

开启rememberme功能

Spring Security使得为应用添加Remember-me功能变得非常容易。为了启用这项功能,只需在configure()方法所传入的HttpSecurity对象上调用rememberMe()即可。

@Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeHttpRequests()
                .antMatchers("/book/*").authenticated() //所有/book/*路径下的都需要验证
                .anyRequest().permitAll()
                .and()
                .rememberMe()						//开启rememberMe功能
                .tokenValiditySeconds(60*60*24*7)	 //设置时间
            	.key("bookkey")					   //存储在cookie中的token包含用户名、密码、过期时间和一个私钥——在写入cookie前都进行了MD5哈希。默认情况下,私钥的名为SpringSecured,但在这里我们将其设置为bookKey,使它专门用于Spittr应用
                .and()
                .csrf().disable();
    }
2.拦截请求
@Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeHttpRequests()
                .antMatchers("/book/*").authenticated() //所有/book/*路径下的都需要验证
                .anyRequest().permitAll();
    }
 

用来定义如何保护路径的配置方法:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Iv50h7TQ-1653878168729)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220406172135331.png)]

​ 续:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zhRPxKSB-1653878168740)(C:UsersAiClvGuAppDataRoamingTyporatypora-user-imagesimage-20220406172209777.png)]

第三部分、后端中的Spring 配置数据源

mysql

持久化框架

Mybatis(Mybatis-plus)、repository、

使用Nosql数据库(Redis重点) Redis

Redis是一种特殊类型的数据库,它被称之为key-value存储。顾名思义,key-value存储保存的是键值对。实际上,key-value存储与哈希Map有很大的相似性。可以不太夸张地说,它们就是持久化的哈希Map

与其他的Spring Data项目类似,Spring Data Redis以模板的形式提供了较高等级的数据访问方案。

实际上,Spring Data Redis提供了两个模板:

RedisTemplate:

​ RedisTemplate可以极大地简化Redis数据访问,能够让我们持久化各种类型的key和value,并不局限于字节数组。

StringRedisTemplate:

​ 在认识到key和value通常是String类型之后,StringRedisTemplate扩展了RedisTemplate,只关注String类型

使用注解保护应用程序

第四部分、Spring集成 Spring消息

rabbitMQ、Kafka

Spring发送邮件

.(img-Iv50h7TQ-1653878168729)]

​ 续:[外链图片转存中…(img-zhRPxKSB-1653878168740)]

第三部分、后端中的Spring 配置数据源

mysql

持久化框架

Mybatis(Mybatis-plus)、repository、

使用Nosql数据库(Redis重点) Redis

Redis是一种特殊类型的数据库,它被称之为key-value存储。顾名思义,key-value存储保存的是键值对。实际上,key-value存储与哈希Map有很大的相似性。可以不太夸张地说,它们就是持久化的哈希Map

与其他的Spring Data项目类似,Spring Data Redis以模板的形式提供了较高等级的数据访问方案。

实际上,Spring Data Redis提供了两个模板:

RedisTemplate:

​ RedisTemplate可以极大地简化Redis数据访问,能够让我们持久化各种类型的key和value,并不局限于字节数组。

StringRedisTemplate:

​ 在认识到key和value通常是String类型之后,StringRedisTemplate扩展了RedisTemplate,只关注String类型

使用注解保护应用程序

第四部分、Spring集成 Spring消息

rabbitMQ、Kafka

Spring发送邮件 SpringBoot简化开发
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936910.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号