springboot项目搭建集成 redis/跨域/远程请求

已于 2024-08-09 08:36:52 修改
阅读量400 收藏 4
点赞数 3
文章标签： spring boot redis java 后端
于 2024-08-08 17:40:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42193908/article/details/141030410
版权

目录

一，创建maven项目

1，左上角file > new > maven project 

2，next 到 创建 Group id 和  Artifact id​编辑​编辑

二，配置springboot

1，配置pom文件，

2，创建启动类

3，配置 yml 文件

三，集成 Redis

1，yml追加配置

2，对 Redis 做些代码配置

3，spring 注解@Configuration类中编写代码访问

4，过滤器 ，获取Redis的代码 注：过滤路径在yml配置文件中配置

5，配置 Redis 数据

6，页面访问controller

四，集成 跨域

1，yml文件配置需要跨域的路径端口

2，过滤器，获取跨域代码

3，spring 注解@Configuration类中编写代码访问

五，集成 远程请求

1，封装工具类

2，通用工具类方法sendRequest

一，创建maven项目

1，左上角file > new > maven project 
2，next 到 创建 Group id 和  Artifact id

        

二，配置springboot

1，配置pom文件，
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.3</version>
	</parent>
	<groupId>cn.yilixun.jt.econtract</groupId>
	<artifactId>jt-econtract</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>com.alibaba.fastjson2</groupId>
			<artifactId>fastjson2</artifactId>
			<version>2.0.12</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-all</artifactId>
			<version>5.8.12</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
		</dependency>

		<dependency>
			<groupId>com.squareup.okhttp3</groupId>
			<artifactId>okhttp-sse</artifactId>
		</dependency>
		<dependency>
			<groupId>com.squareup.okhttp3</groupId>
			<artifactId>okhttp</artifactId>
		</dependency>

		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>3.5.4.1</version>
		</dependency>

		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-generator</artifactId>
			<version>3.5.4.1</version>
		</dependency>

		<dependency>
			<groupId>org.mybatis.scripting</groupId>
			<artifactId>mybatis-velocity</artifactId>
			<version>2.1.2</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-validation</artifactId>
		</dependency>
		<dependency>
			<groupId>com.google.zxing</groupId>
			<artifactId>core</artifactId>
			<version>3.3.0</version>
		</dependency>

		<dependency>
			<groupId>com.google.zxing</groupId>
			<artifactId>javase</artifactId>
			<version>3.2.1</version>
		</dependency>

		<!-- 分页插件 -->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper-spring-boot-starter</artifactId>
			<version>1.4.2</version>
		</dependency>

		<!-- easypoi的支持 -->
		<dependency>
			<groupId>cn.afterturn</groupId>
			<artifactId>easypoi-base</artifactId>
			<version>3.2.0</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<mainClass>cn.yilixun.jt.econtract.portal.EcontractPortalStartup</mainClass>
				</configuration>
				<executions>
					<execution>
						<goals>
							<goal>repackage</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>
2，创建启动类
package cn.yilixun.jt.econtract.portal;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.ComponentScan;

/**
 * Hello world!
 *
 */
@SpringBootApplication
@ComponentScan(basePackages = { "cn.yilixun.*" })
@MapperScan("cn.yilixun.jt.econtract.portal.mapper")
@EnableConfigurationProperties
public class EcontractPortalStartup {
	
	public static void main(String[] args) {
		SpringApplication.run(EcontractPortalStartup.class, args);
	}
}
3，配置 yml 文件

application.yml

spring:
  application:
    name: portal
  profiles:
    active: dev
  jackson:
    default-property-inclusion: non_null
    time-zone: GMT+8
  main:
    allow-bean-definition-overriding: true 
mybatis-plus:
  mapper-locations: classpath:/mybatis/*.xml
  type-aliases-package: cn.yilixun.jt.econtract.portal.info
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
#日志配置
logging:
  config: classpath:logback-spring.xml
  level:
    org.springframework: warn
access:
  ignore-pattern: /*|
  control:
    allow:
      origin: http://localhost:8080

application-dev.yml

server:
  port: 10000
  servlet:
    context-path: /econtract
logging:
  file:
    path: D:\logs
spring:
  redis:
    host: 172.16.1.205
    port: 6379
    database: 8
    password: "Redis12#$56"
    timeout: 10s
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://172.16.1.205:3306/jt_econtract?serverTimezone=GMT%2B8&remarks=true&useInformationSchema=true&tinyInt1isBit=true&allowMultiQueries=true
    username: jt_econtract
    password: JTecontract@2024.

至此，springboot项目生成完毕

三，集成 Redis

1，yml追加配置

2，对 Redis 做些代码配置
package cn.yilixun.jt.econtract.portal.cache;

import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;

public class RedisCache {
	
	public final static long REDIS_EXPIRE_TIME = 7200L;
	
	public final static String REDIS_KEY_USER_TOKEN = "user-token:";
	
	public final static String REDIS_KEY_BASE_DATA = "base-data:";

	private RedisTemplate<String, String> redisTemplate;
	
	public RedisCache(RedisTemplate<String, String> redisTemplate) {
		this.redisTemplate = redisTemplate;
	}

	public void hset(final String key, final String hashKey, final Object value) {
		this.redisTemplate.opsForHash().put(key, hashKey, JSON.toJSONString(value));
	}
	
	public String hget(final String key, final String hashKey) {
		HashOperations<String,Object,Object> operation = this.redisTemplate.opsForHash();
		if (operation != null && operation.get(key, hashKey) != null) {
			return (String)operation.get(key, hashKey);
		}
		return null;
	}

	public void set(final String key, final Object value) {
		this.redisTemplate.opsForValue().set(key, JSON.toJSONString(value));
	}

	public void set(final String key, final Object value, final long timeout, final TimeUnit timeUnit) {
		this.redisTemplate.opsForValue().set(key, JSON.toJSONString(value), timeout, timeUnit);
	}

	public String get(final String key) {
		ValueOperations<String, String> operation = this.redisTemplate.opsForValue();
		return operation.get(key);
	}

	public boolean expire(final String key, final long timeout) {
		return this.expire(key, timeout, TimeUnit.SECONDS);
	}

	public boolean expire(final String key, final long timeout, final TimeUnit unit) {
		return this.redisTemplate.expire(key, timeout, unit);
	}

	public boolean delete(final String key) {
		return this.redisTemplate.delete(key);
	}
	
	public void createUserToken(String token, Object user) {
		if (user != null) {
			this.set(RedisCache.REDIS_KEY_USER_TOKEN + token, user, RedisCache.REDIS_EXPIRE_TIME, TimeUnit.SECONDS);
		}
	}
	public JSONObject getLoginUserInfo(String token) {
		Object obj = this.get(RedisCache.REDIS_KEY_USER_TOKEN + token);
		if (obj != null) {
			this.expire(RedisCache.REDIS_KEY_USER_TOKEN + token, RedisCache.REDIS_EXPIRE_TIME, TimeUnit.SECONDS);
			return JSONObject.parseObject(obj.toString());
		}
		return null;
	}

}
3，spring 注解@Configuration类中编写代码访问
package cn.yilixun.jt.econtract.portal.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;

import cn.yilixun.jt.econtract.portal.cache.RedisCache;
import cn.yilixun.jt.econtract.portal.filter.SimpleCorsFilter;

@Configuration
public class PropertiesConfig {
	@Autowired
	private RedisTemplate<String, String> redisTemplate;

	@Bean
	public RedisCache redisCache() {
		return new RedisCache(this.redisTemplate);
	}

	
}
4，过滤器 ，获取Redis的代码 注：过滤路径在yml配置文件中配置
package cn.yilixun.jt.econtract.portal.filter;

import java.io.IOException;
import java.util.regex.Pattern;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import com.alibaba.fastjson2.JSONObject;

import cn.yilixun.jt.econtract.portal.cache.RedisCache;



@Component
@WebFilter(urlPatterns = {"/*"})
@Order(1)
public class AccessVerifyFilter implements Filter {
    @Value("${access.ignore-pattern:}")
    private String ignoreLoginUri;
    @Autowired
    private RedisCache redisCache;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        String token = req.getHeader("User-Token");
        if (!StringUtils.hasLength(token)) {
            token = req.getParameter("userToken");
        }
        JSONObject user = redisCache.getLoginUserInfo(token);
        String path = req.getServletPath();
        if (!this.isIgnoreUri(this.ignoreLoginUri, path) && (user == null || user.isEmpty())) {
            JSONObject erInfo = new JSONObject();
            erInfo.put("state", 900);
            erInfo.put("code", "302");
            this.writeResponse(response, erInfo);
            return;
        }

        chain.doFilter(request, response);
    }

    private void writeResponse(ServletResponse response, JSONObject msg) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        response.getWriter().write(msg.toJSONString());
        response.getWriter().flush();
    }

    private boolean isIgnoreUri(String patternsStr, String path) {
        if (StringUtils.hasLength(patternsStr)) {
            String[] patterns = patternsStr.split("\\|");
            if (patterns.length > 0) {
                for (String p : patterns) {
                    if (StringUtils.hasLength(p) && Pattern.matches(p.replace("*", ".*"), path)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

}
5，配置 Redis 数据

6，页面访问controller
package cn.yilixun.jt.econtract.portal.controller;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.alibaba.fastjson2.JSONObject;

import cn.yilixun.jt.econtract.portal.cache.RedisCache;
import cn.yilixun.jt.econtract.portal.response.ResponseResult;


@RestController
@RequestMapping("/")
public class PortalController {

    @Autowired
    protected RedisCache redisCache;
    
    @GetMapping("/getBaseInfo")
    public JSONObject dictList(HttpServletRequest req) {
    	String token = req.getHeader("User-Token");
        if (!StringUtils.hasLength(token)) {
            token = req.getParameter("userToken");
        }
        JSONObject user = redisCache.getLoginUserInfo(token);
        return ResponseResult.success(user);
    }

}

        

至此，Redis 集成结束

四，集成 跨域

1，yml文件配置需要跨域的路径端口

2，过滤器，获取跨域代码

package cn.yilixun.jt.econtract.portal.filter;

import java.io.IOException;
import java.util.Arrays;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * SimpleCORSFilter.
 * @Title:SimpleCORSFilter.java
 * @Description SimpleCORSFilter.java
 */
public class SimpleCorsFilter implements Filter {
    
    private String originUrl;
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        originUrl = filterConfig.getInitParameter("originUrl");
    }
    
    /**
     * 请求过滤器.
     */
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) 
            throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        HttpServletRequest re = (HttpServletRequest) req;
        String url = re.getHeader("Origin");
        String[] urlArray = originUrl.split(",");
        if (Arrays.asList(urlArray).contains(url)) {
            response.setHeader("Access-Control-Allow-Origin", url);
        }
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "x-requested-with,content-type,token,Access-Token");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        chain.doFilter(req, res);
    } 
}
3，spring 注解@Configuration类中编写代码访问
package cn.yilixun.jt.econtract.portal.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;

import cn.yilixun.jt.econtract.portal.cache.RedisCache;
import cn.yilixun.jt.econtract.portal.filter.SimpleCorsFilter;

@Configuration
public class PropertiesConfig {

	@Value("${access.control.allow.origin}")
	private String originUrl;


	/**
	 * 跨域过滤器.
	 * 
	 * @return
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Bean
	public FilterRegistrationBean filterRegist() {
		FilterRegistrationBean frBean = new FilterRegistrationBean();
		frBean.setFilter(new SimpleCorsFilter());
		frBean.addUrlPatterns("/*");
		frBean.addInitParameter("originUrl", originUrl);
		return frBean;
	}
}

至此，跨域集成结束

五，集成 远程请求

1，封装工具类
package cn.yilixun.jt.econtract.portal.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;

import com.alibaba.fastjson2.JSONObject;

import lombok.extern.log4j.Log4j2;

@Log4j2
public class RestTemplateUtil {
	
    /**
     * 发送请求.
     *
     * @param method not null
     * @return
     */
    public static JSONObject sendRequest(String url, HttpMethod method, Object bodyParams, JSONObject headerParams) throws Exception {
        log.info("RestTemplateUtil.sendRequest start :: [url] = " + url + ", [method] = " + method);
        RestTemplate rest = new RestTemplate();
        rest.getMessageConverters().add(new WxMappingJackson2HttpMessageConverter());
        HttpEntity<Object> request = RestTemplateUtil.getRequestEntity(bodyParams, headerParams);
        ResponseEntity<JSONObject> res = rest.exchange(url, method, request, JSONObject.class);
        if (res == null || res.getBody() == null) {
            throw new Exception("获取api数据异常");
        }
        log.info("RestTemplateUtil.sendRequest end :: " + res.getBody().toString());
        return res.getBody();
    }

    private static HttpEntity<Object> getRequestEntity(Object rbp, JSONObject rhp) {
        MultiValueMap<String, String> header = new LinkedMultiValueMap<>();
        if (rhp != null && !rhp.isEmpty()) {
            for (String key : rhp.keySet()) {
                header.add(key, rhp.getString(key));
            }
        }
        return new HttpEntity<>(rbp, header);
    }
    
    /**
     * 发送请求.
     *
     * @param method not null
     * @return
     */
    public static JSONObject sendRequestMap(String url, HttpMethod method, Map<String, Object> requestBodyParams, Map<String, String> requestHeaderParams) throws Exception {
        log.info("RestTemplateUtil.sendRequest start :: [url] = " + url + ", [method] = " + method);
        RestTemplate rest = new RestTemplate();
        rest.getMessageConverters().add(new WxMappingJackson2HttpMessageConverter());
        HttpEntity<Map<String, Object>> request = getRequest(requestBodyParams, requestHeaderParams);
        if (method == HttpMethod.GET) {
            url = convetUrl(url, requestBodyParams);
        }
        ResponseEntity<JSONObject> res = rest.exchange(url, method, request, JSONObject.class);
        if (res == null || res.getBody() == null) {
            throw new Exception("获取api数据异常");
        }
        log.info("RestTemplateUtil.sendRequest end :: " + res.getBody().toString());
        return res.getBody();
    }

    /**
     * 请求配置.
     *
     * @Param :authorization
     * @Return :HttpEntity
     */
    private static HttpEntity<Map<String, Object>> getRequest(Map<String, Object> rbp, Map<String, String> rhp) {
        Map<String, Object> body = new HashMap<>();
        HttpHeaders header = new HttpHeaders();
        if (rbp != null && !rbp.isEmpty()) {
            for (String key : rbp.keySet()) {
                body.put(key, rbp.get(key));
            }
        }
        if (rhp != null && !rhp.isEmpty()) {
            for (String key : rhp.keySet()) {
                header.add(key, rhp.get(key));
            }
        }
        return new HttpEntity<>(body, header);
    }

    public static class WxMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {
        /**
         * RestTemplate 把数据从 HttpResponse 转换成 Object 的时候，找不到合适的 HttpMessageConverter 来转换
         * 需要继承 MappingJackson2HttpMessageConverter 并在构造过程中设置其支持的 MediaType 类型.
         */
        public  WxMappingJackson2HttpMessageConverter() {
            List<MediaType> mediaTypes = new ArrayList<>();
            mediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
            setSupportedMediaTypes(mediaTypes);
        }
    }

    /**
     * get请求url拼接参数.
     * @Param :authorization
     * @Return :HttpEntity
     */
    public static String convetUrl(String url, Map<String, Object> param) {
        String paramUrl = "";
        if (param != null) {
            for (Map.Entry<String, Object> e : param.entrySet()) {
                paramUrl+=(e.getKey() + "=" + e.getValue() + "&");
            }
        }
        if (StringUtils.hasLength(paramUrl)) {
            return url + "?" + paramUrl.substring(0, paramUrl.length() - 1);
        }
        return url;
    }
}
2，通用工具类方法sendRequest
private void executeAfterStartup() {
        JSONObject jsonObject = null;
        try {
            jsonObject = RestTemplateUtil.sendRequest("http://localhost:8080/aaaaa", HttpMethod.POST,new JSONObject(), null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if ("10".equals(jsonObject.get("code").toString())) {
          JSONObject jsonObject  = jsonObject.get("data");
        }
    }

至此，远程请求集成结束

B2C电商项目（第二天、项目整体框架的CRUD、跨域解决方案、搭建分布式文件存储FastDFS完成文件上传、搭建微服务网管Gateway解决跨域，微服务网关过滤器过滤器）
落日的博客
05-30 559
项目整体框架的CRUD、跨域解决方案、搭建分布式文件存储FastDFS完成文件上传、搭建微服务网管Gateway解决跨域，微服务网关过滤器过滤器
《项目实战》构建SpringCloud alibaba项目（一、构建父工程、公共库、网关））
热门推荐
Java 技术专栏，从入门到精通，熟悉企业级开发
06-15 1万+
本章节讲解如何构建SpringCloud alibaba项目，以父子工程形式搭建。 - 父工程规范Springboot版本、SpringCloud版本、SpringCloud alibaba版本； - 子工程包括公共方法库（公共的DTO、http统一返回类（枚举code码等）），Gateway网关（集成Sentinel）、内网微服务统一接口层、内网微服务发布方、内网微服务调用方等；
SpringBoot远程访问Linux中Redis服务器
Code-Zhao
11-12 2716
首先在linux中安装Redis 将下载好的包解压到指定目标。（这里是根目录下的app文件夹） tar -zxvf redis-4.0.11.tar.gz -C /app 进入Redis安装文件夹 /app/redis-4.0.11  PS：新安装的linux系统没有安装gcc环境、需要安装gcc，为了方便采取一键安装方式  # yum install gcc 验证gcc是否安装成功：#...
SpringBoot连接远程服务器redis
weixin_51713937的博客
01-18 876
进入redis安装地址，我这里安装的是 /usr/local/src/redis-6.2.6先copy一份配置文件然后修改配置文件信息启动redis去云服务器安全组中开放端口重启防火墙查看6379的防火墙状态。
Springboot 整合redis 入门示例
cui163007的博客
10-05 305
Springboot 整合redis 入门示例 工具 eclipse mar jkd1.8 maven3.5.3 springboot2.1.0 1 添加redis依赖(当springBoot的版本为1.4.7 以上的时候,需要引入下边的版本) <!-- 引入redis依赖 --> <dependency> ...
项目中集成redis
Java—wang的博客
07-30 645
!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- spring2.X集成redis所需common-pool2--> <dependency..
springboot远程连接redis
qq_45100750的博客
08-23 687
单机版 第一步 先配置好单机版的配置文件 在单机版redis的配置文件/usr/local/redis/bin/redis.conf 文件中 将daemonize修改为yes 将protected-mode修改为no 要是没有protected-mode自行添加 这里的bind也应该是注释状态 第二步 新建redis模块 这里是他所需要的依赖 <dependencies> <!-- Spring Session 分布式事务 ，在登录时使用 -->
SpringBoot面试题（2020最新版）-重点.pdf
11-25
Spring Boot 提供了对跨域请求的支持，可以通过 @CrossOrigin 注解或配置 CORS 过滤器实现。 Spring Boot 内置了 Actuator 监控端点，用于监控应用健康状况和性能指标。Actuator 的安全性可以通过设置management....
【云原生网关】Kong 使用详解
congge
05-02 5669
云原生网关kong使用详解
项目概述、环境搭建-苍穹外卖（第一天）
最新发布
lzping_719的专栏
12-26 189
作为一名软件开发工程师,我们需要了解在软件开发过程中的开发流程， 以及软件开发过程中涉及到的岗位角色，角色的分工、职责， 并了解软件开发中涉及到的三种软件环境。那么这一小节，我们将从 软件开发流程、角色分工、软件环境 三个方面整体介绍一下软件开发。在开发苍穹外卖这个项目之前，我们需要全方位的来介绍一下当前我们学习的这个项目。接下来，我们将从项目简介、产品原型、技术选型三个方面来介绍苍穹外卖这个项目。
基于SpringBoot集成测试远程连接Redis服务的教程详解
08-19
主要介绍了基于SpringBoot集成测试远程连接的Redis服务的相关知识，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
springboot连接redis简单示例
10-24
springboot连接redis简单示例。其中含连接redis的dao层和controller层，可以通过页面访问进行测试。
springboot项目连接数据库及redis实例
01-23
使用springboot搭建，连接mysql数据库以及redis缓存。需要修改数据库和redis配置才能正常运行。
Springboot项目远程连接Redis
July的博客
03-30 552
查看redis安装目录 whereis redis-server redis配置文件中修改 protected-mode no 以及 注释掉 bind 127.0.0.1 在redis安装目录下执行 redis-server /路径/redis.conf & 启动redis redis-cli 进入客户端
Springboot远程连接redis服务器（仅连接上）
qiuhalouha_1的博客
03-19 1262
1. 导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2.配置连接（这里只需配置password 和 host） spring:
springboot远程连接云服务redis服务端
各位多多关照
04-25 1019
springboot redis 远程连接 服务器
SpringBoot远程访问redis服务器
夜闯秋名山吃瓜皮
04-23 4206
springboot redis
SpringBoot连接redis
make_progress的博客
07-01 1万+
1.2 设置配置文件 手动创建redis.conf，并添加如下配置参数。 也可以在网上下载redis配置文件，注意需要修改里面的配置。 授权配置文件 1.3 生成容器 2 简单使用redis 3 SpringBoot连接redis 3.1 工程结构 3.3 application.yml 3.4 conf ConfigRedis.java 3.5 controller RequestController.java 3.6 entity User.java...
SpringBoot连接Redis且解决乱码
李长渊的博客
07-25 1060
SpringBoot连接Redis且解决乱码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>