springboot快速入门一篇文章全
【摘要】 编辑springboot快速入门一篇文章全 springboot01、基本配置springboot简介Spring Boot 为简化 Spring 应用开发而生，Spring Boot 中的 Boot 一词，即为快速启动的意思。Spring Boot 可以在零配置情况下一键启动，简洁而优雅。为了让 Spring 开发者痛快到底，Spring 团队做了以下设计：简化依赖，提供整合的依赖项...
springboot快速入门一篇文章全
springboot01、基本配置
springboot简介
Spring Boot 为简化 Spring 应用开发而生，Spring Boot 中的 Boot 一词，即为快速启动的意思。Spring Boot 可以在零配置情况下一键启动，简洁而优雅。
为了让 Spring 开发者痛快到底，Spring 团队做了以下设计：
- 简化依赖，提供整合的依赖项，告别逐一添加依赖项的烦恼；
- 简化配置，提供约定俗成的默认配置，告别编写各种配置的繁琐；
- 简化部署，内置 servlet 容器，开发时一键即运行。可打包为 jar 文件，部署时一行命令即启动；
- 简化监控，提供简单方便的运行监控方式。
基于以上设计目的，Spring 团队推出了 Spring Boot 。
目录
1、pom.xml
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.4.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>2、项目层次
3、启动文件【com.item/Action.java】
package com.item;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Action {
public static void main(String[] args) {
SpringApplication.run(Action.class,args);//一定是被@SpringBootApplication标记的类
}
}
4、controller文件
其中@RestController = @Controller + @ResponseBody；
package com.item.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
@RestController
@CrossOrigin
public class UsersController {
@GetMapping("GetInfo")
public Object GetInfo(){
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","有一个字符串");
return map;
}
}
5、启动测试（数据是跨域的）
访问路径：【】
springboot02、打war包
Spring Boot 打包为 war 并运行
将 Spring Boot 打包为 war ，然后放置于 Tomcat 的 webapps 目录下加载运行，接下来我们就详细描述下打包为 war 的过程。
目录
1、修改打包方式
在【pom.xml】文件中修改默认的打包方式，显式指定打包方式为 war。
<name>demospring</name>
<packaging>war</packaging>
由于 Spring Boot 内置了 Tomcat ，所以我们在打包时需要排除内置的 Tomcat ，这样可以避免内置 Tomcat 和 war 包部署运行的 Tomcat 产生冲突。在 pom.xml 中添加如下依赖即可：
<!-- 阻断器·打包的是否排除内置的tomcat -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>2、修改启动文件【Action.java】
package com.item;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class Action extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Action.class);
}
public static void main(String[] args) {
SpringApplication.run(Action.class,args);//一定是被@SpringBootApplication标记的类
}
}
3、打包命令
项目路径中打开【cmd】并执行
mvn clean package -Dmaven.test.skip=true
4、打包效果：
使用
mvn clean package -Dmaven.test.skip=true命令打包应用了，运行命令后会在 target 目录下生成 war 文件，将该文件放置于 Tomcat 的 webapps 目录下运行即可。
前后端分离部署的方式，更能发挥服务器的性能，如果要进行版本升级，直接替换后端war包就OK。
springboot03、实现mybatis
目录
1、pom引包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- 热部署 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
<!-- Web支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- JDBC -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- 集成MyBatis -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.2</version>
</dependency>
<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<!-- 测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
2、数据源配置application.properties
Spring Boot 会将数据源自动注入到 MyBatis 的 sqlSessionFactory 组件中。对于我们开发者来说，这一切都是自动实现的，非常简单。
# 配置数据库驱动
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 配置数据库url
spring.datasource.url=jdbc:mysql://rm-bp1zq3879r28p726lco.mysql.rds.aliyuncs.com:3306/test?characterEncoding=utf8
# 配置数据库用户名
spring.datasource.username=qwe8403000
# 配置数据库密码
spring.datasource.password=Qwe8403000
# 指定MyBatis配置文件位置
mybatis.mapper-locations=classpath:mapper/*.xml
# 指定模型位置
mybatis.typeAliasesPackage=com.item.model
# 修改端口号避免冲突
server.port=8088
# 服务路径
server.servlet.context-path=/demospring
3、model对应数据库的类Users
package com.item.model;
public class Users {
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
@Override
public String toString() {
return "Users{" +
"id=" + id +
", userName='" + userName + '\'' +
", pwd='" + pwd + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
private int id;
private String userName;
private String pwd;
private String nickName;
}4、dao层·需要加上@Repository注解
package com.item.dao;
import com.item.model.Users;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 数据访问组件
*/
@Repository
public interface UsersMapper {
List<Users> GetInfo();
List<Users> SelectName(@Param("nickName") String nickName);
Users UsersSelectById(@Param("id") int id);
int UsersAddInfo(
@Param("userName") String userName,
@Param("pwd") String pwd,
@Param("nickName") String nickName
);
int UsersUpdateInfo(
@Param("pwd") String pwd,
@Param("id") int id
);
int UsersDeleteById(@Param("id") int id);
}5、添加映射文件UsersMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.item.dao.UsersMapper">
<!-- 用作基础查询测试 -->
<select id="GetInfo" resultType="Users">
select * from users
</select>
<!-- 用做传递参数测试 -->
<select id="SelectName" resultType="Users">
select * from users where nickName like "%${nickName}%"
</select>
<!-- id精准查询 -->
<select id="UsersSelectById" resultType="Users">
select * from users where id=#{id}
</select>
<!-- 增加 -->
<insert id="UsersAddInfo">
insert into users values(0,"${userName}","${pwd}","${nickName}");
</insert>
<!-- 修改 -->
<update id="UsersUpdateInfo">
update users set pwd="${pwd}" where id=#{id}
</update>
<!-- 删除 -->
<delete id="UsersDeleteById">
delete from users where id=#{id}
</delete>
</mapper>6、service层编码
package com.item.service;
import com.item.model.Users;
import java.util.List;
public interface UsersService {
/**
* 获取所有
* @return
*/
List<Users> GetInfo();
/**
* 获取nickName的模糊查询结果集
* @param nickName
* @return
*/
List<Users> SelectName(String nickName);
/**
* id精准查询
* @param id
* @return
*/
Users UsersSelectById(int id);
/**
* 添加信息
* @param userName
* @param pwd
* @param nickName
* @return
*/
int UsersAddInfo(
String userName,
String pwd,
String nickName
);
/**
* 修改密码
* @param pwd
* @param id
* @return
*/
int UsersUpdateInfo(
String pwd,
int id
);
/**
* 删除信息
* @param id
* @return
*/
int UsersDeleteById(int id);
}7、serviceimpl层编码
package com.item.serviceimpl;
import com.item.dao.UsersMapper;
import com.item.model.Users;
import com.item.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;
@Service
public class UsersServiceImpl implements UsersService {
@Autowired
private UsersMapper usersMapper;
@Override
public List<Users> GetInfo() {
return usersMapper.GetInfo();
}
@Override
public List<Users> SelectName(String nickName) {
return usersMapper.SelectName(nickName);
}
@Override
public Users UsersSelectById(int id) {
return usersMapper.UsersSelectById(id);
}
@Override
public int UsersAddInfo(String userName, String pwd, String nickName) {
pwd=encrypt(pwd);
return usersMapper.UsersAddInfo(userName, pwd, nickName);
}
@Override
public int UsersUpdateInfo(String pwd, int id) {
pwd=encrypt(pwd);
return usersMapper.UsersUpdateInfo(pwd, id);
}
/**
* MD5加密
* @param password
* @return
*/
private String encrypt(String password) {
String passwordMd5 = null;
try {
MessageDigest md5 = MessageDigest.getInstance("MD5");
byte[] bytes = md5.digest(password.getBytes("utf-8"));
passwordMd5 = toHex(bytes);
} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
e.printStackTrace();
}
return passwordMd5;
}
private static String toHex(byte[] bytes) {
final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();
StringBuilder ret = new StringBuilder(bytes.length * 2);
for (int i = 0; i < bytes.length; i++) {
ret.append(HEX_DIGITS[(bytes[i] >> 4) & 0x0f]);
ret.append(HEX_DIGITS[bytes[i] & 0x0f]);
}
return ret.toString();
}
@Override
public int UsersDeleteById(int id) {
return usersMapper.UsersDeleteById(id);
}
}8、Controller层编码
package com.item.controller;
import com.item.model.Users;
import com.item.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
@RestController
@CrossOrigin
public class UsersController {
@Autowired
private UsersService usersService;
@GetMapping("/GetInfoApi")
public Object GetInfoApi(){
List<Users> list=usersService.GetInfo();
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result",list);
return map;
}
@GetMapping("/GetName")
public Object GetName(HttpServletRequest request,Model model){
String nickName = request.getParameter("nickName");
List<Users> list=usersService.SelectName(nickName);
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result",list);
return map;
}
/**
* 添加接口，访问方式post
* @param request
* @param model
* @return
*/
@PostMapping(value = "/UserAddInfoApi")
public Object UserAddInfoApi(HttpServletRequest request,Model model){
String userName = request.getParameter("userName");
String pwd = request.getParameter("pwd");
String nickName = request.getParameter("nickName");
usersService.UsersAddInfo(userName, pwd, nickName);
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
/**
* 单个查询
* @param request
* @param model
* @return
*/
@GetMapping("/UsersSelectById")
public Object UsersSelectById(HttpServletRequest request,Model model){
String id = request.getParameter("id");
Users users = usersService.UsersSelectById(Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result",users);
return map;
}
/**
* 修改api
* @param request
* @param model
* @return
*/
@PostMapping(value = "/UserUpdateInfoApi")
public Object UserUpdateInfoApi(HttpServletRequest request,Model model){
String id = request.getParameter("id");
String pwd = request.getParameter("pwd");
usersService.UsersUpdateInfo(pwd,Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
/**
* 删除api
* @param request
* @param model
* @return
*/
@GetMapping(value = "/UsersDeleteById")
public Object UsersDeleteById(HttpServletRequest request,Model model){
String id = request.getParameter("id");
usersService.UsersDeleteById(Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
}备注：dao层引入
package com.item;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@MapperScan("com.item.dao")
@SpringBootApplication
public class Action extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Action.class);
}
public static void main(String[] args) {
SpringApplication.run(Action.class,args);//一定是被@SpringBootApplication标记的类
}
}9、测试效果：
可以使用postman测试：
效果很明显，成功了。
StringUtils判断字符串是否为空
可以直接看到测试效果，无论是null还是""都是空。
StringUtils依赖包：
<!-- 判断字符串是否为空 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.8.1</version>
</dependency>StringUtils测试编码：
import org.apache.commons.lang3.StringUtils;
public class Action {
public static void main(String[] args) {
String a=null;
String b="";
if(StringUtils.isEmpty(a)){
System.out.println("a空");
}
if(StringUtils.isEmpty(b)){
System.out.println("b空");
}
}
}
StringUtils测试效果：
springboot04、swagger配置
前言：
springboot的swagger配置与SSM稍微有些不同，SSM对2.9.0以上的兼容性很差，但是springboot就可以使用2.9.0以上的包了，其实区别不算太大，除了能对对象直接操作外就是页面更清爽了。
目录
4、启动效果：【http://127.0.0.1:8088/swagger-ui.html】
1、pom依赖
<!-- swagger包这里2.9.2 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>2、swagger配置文件
这里单独创建了一个包【com.item.swagger】来放置swagger的配置文件
需要注意的是：【com.item.controller】这里需要改成自己的包位置。
package com.item.swagger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
private static Logger log = LoggerFactory.getLogger(SwaggerConfig.class);
@Bean
public Docket createRestApi() {
log.info("进入到swagger的配置中");
return new Docket(DocumentationType.SWAGGER_2)
// 指定构建api文档的详细信息的方法：apiInfo()
.apiInfo(apiInfo())
.groupName("红目香薰")
.select()
// 指定要生成api接口的包路径，这里把controller作为包路径，生成controller中的所有接口
.apis(RequestHandlerSelectors.basePackage("com.item.controller"))
.paths(PathSelectors.any())
.build();
}
/**
* 构建api文档的详细信息
* @return
*/
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
// 设置页面标题
.title("Spring Boot集成Swagger2接口总览")
// 设置接口描述
.description("Swagger接口")
// 设置联系方式
.contact(new Contact("测试swagger","http://localhost:8080/",""))
// 设置版本
.version("1.0")
// 构建
.build();
}
}3、接口api写法
我写了一套的注释方法，一目了然
package com.item.controller;
import com.item.model.Users;
import com.item.service.UsersService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
@Api("用户操作接口")
@RestController
@CrossOrigin
public class UsersController {
@Autowired
private UsersService usersService;
/**
* 获取所有信息
* @return
*/
@GetMapping("/GetInfoApi")
@ApiOperation(value = "获取信息",notes = "没啥留言的")
public Object GetInfoApi(){
List<Users> list=usersService.GetInfo();
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result",list);
return map;
}
@GetMapping("/GetName")
@ApiOperation(value = "获取信息",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "通过昵称模糊查询")
})
public Object GetName(HttpServletRequest request,Model model){
String nickName = request.getParameter("nickName");
List<Users> list=usersService.SelectName(nickName);
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result",list);
return map;
}
/**
* 添加信息
* @param userName
* @param pwd
* @param nickName
* @return
*/
@PostMapping(value = "/UserAddInfoApi")
@ApiOperation(value = "添加",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "userName",required = true,paramType = "query",dataType = "String",value = "用户名"),
@ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
@ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "昵称")
})
public Object UserAddInfoApi(String userName,String pwd,String nickName){
HashMap<String,Object> map=new HashMap<String,Object>();
if(
StringUtils.isEmpty(userName)||
StringUtils.isEmpty(pwd)||
StringUtils.isEmpty(nickName)
){
map.put("state",false);
map.put("msg","参数不润许为空");
map.put("result","");
return map;
}
usersService.UsersAddInfo(userName, pwd, nickName);
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
/**
* 单个查询
* @param id
* @return
*/
@GetMapping("/UsersSelectById")
@ApiOperation(value = "id查询",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
})
public Object UsersSelectById(String id){
Users users = usersService.UsersSelectById(Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result",users);
return map;
}
/**
* 修改api
* @param id
* @param pwd
* @return
*/
@PostMapping(value = "/UserUpdateInfoApi")
@ApiOperation(value = "添加",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号"),
@ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
})
public Object UserUpdateInfoApi(String id,String pwd){
usersService.UsersUpdateInfo(pwd,Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
/**
* 删除api
* @param id
* @return
*/
@GetMapping(value = "/UsersDeleteById")
@ApiOperation(value = "根据id删除",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
})
public Object UsersDeleteById(String id){
usersService.UsersDeleteById(Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
}4、启动效果：【】
这里为了看着方便，我将服务路径改为了【/】
# 服务路径
server.servlet.context-path=/
5、使用方法
POST的也类似
6、可能出现的异常总结：
1、SwaggerConfig的配置文件中忘记写注解，就2个注解：
@Configuration
@EnableSwagger22、接口中的注解：
@Api("用户操作接口")
@ApiOperation(value = "获取信息",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "通过昵称模糊查询")
})3、没有明确接口的访问类型，导致出现一堆的同名不同访问类型的接口提示。
使用@GetMapping或者@PostMapping就可以解决此问题。
springboot05、封装结果集
不可能一直用map写数据返回，很麻烦的，那么咱们就可以进行一次封装此次使用。
目录
编辑一个SUCCESS类和ERROR类，他们都有state、msg、result，那么就创建一个公用的父类base。
创建【com.item.res】包
Base：
package com.item.res;
public class BASE {
private boolean state;
private String msg;
private Object result;
public BASE(boolean state, String msg, Object result) {
this.state = state;
this.msg = msg;
this.result = result;
}
public boolean isState() {
return state;
}
public void setState(boolean state) {
this.state = state;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Object getResult() {
return result;
}
public void setResult(Object result) {
this.result = result;
}
}
ERROR：
package com.item.res;
public class ERROR extends BASE {
public ERROR(String msg, Object result) {
super(false, msg, result);
}
}
SUCCESS：
package com.item.res;
public class SUCCESS extends BASE {
public SUCCESS(Object result) {
super(false, "操作成功", result);
}
}
返回修改：
package com.item.controller;
import com.item.model.Users;
import com.item.res.ERROR;
import com.item.res.SUCCESS;
import com.item.service.UsersService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
@Api("用户操作接口")
@RestController
@CrossOrigin
public class UsersController {
@Autowired
private UsersService usersService;
/**
* 获取所有信息
* @return
*/
@GetMapping("/GetInfoApi")
@ApiOperation(value = "获取信息",notes = "没啥留言的")
public Object GetInfoApi(){
List<Users> list=usersService.GetInfo();
return new SUCCESS(list);
}
@GetMapping("/GetName")
@ApiOperation(value = "获取信息",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "通过昵称模糊查询")
})
public Object GetName(HttpServletRequest request,Model model){
String nickName = request.getParameter("nickName");
List<Users> list=usersService.SelectName(nickName);
return new SUCCESS(list);
}
/**
* 添加信息
* @param userName
* @param pwd
* @param nickName
* @return
*/
@PostMapping(value = "/UserAddInfoApi")
@ApiOperation(value = "添加",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "userName",required = true,paramType = "query",dataType = "String",value = "用户名"),
@ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
@ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "昵称")
})
public Object UserAddInfoApi(String userName,String pwd,String nickName){
HashMap<String,Object> map=new HashMap<String,Object>();
if(
StringUtils.isEmpty(userName)||
StringUtils.isEmpty(pwd)||
StringUtils.isEmpty(nickName)
){
return new ERROR("参数为空","参数错误");
}
usersService.UsersAddInfo(userName, pwd, nickName);
return new SUCCESS("添加成功");
}
/**
* 单个查询
* @param id
* @return
*/
@GetMapping("/UsersSelectById")
@ApiOperation(value = "id查询",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
})
public Object UsersSelectById(String id){
Users users = usersService.UsersSelectById(Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result",users);
return map;
}
/**
* 修改api
* @param id
* @param pwd
* @return
*/
@PostMapping(value = "/UserUpdateInfoApi")
@ApiOperation(value = "添加",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号"),
@ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
})
public Object UserUpdateInfoApi(String id,String pwd){
usersService.UsersUpdateInfo(pwd,Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
/**
* 删除api
* @param id
* @return
*/
@GetMapping(value = "/UsersDeleteById")
@ApiOperation(value = "根据id删除",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
})
public Object UsersDeleteById(String id){
usersService.UsersDeleteById(Integer.parseInt(id));
HashMap<String,Object> map=new HashMap<String,Object>();
map.put("state",true);
map.put("msg","成功");
map.put("result","");
return map;
}
}使用swagger访问测试返回效果如下：
设置完成。
注意问题：
每个人的习惯方式均不同，需要看看公司具体用什么方式：
也可能是这样返回：
{
“code”: -9999,
“message”: “Invalid Request”,
“data”:{ }
}
注意：无论是【ERROR】还是【SUCCESS】他们的返回结果都需要一致，否则前端在处理的时候就会很麻烦，对是一套解析，错又是一套解析，很麻烦。
例如：
正确返回:
{
"state": true,
"message": "访问成功",
"data":
[
{
"id": 77,
"userName": "子玉等于摸鱼",
"pwd": "074FD28EFF0F5ADEA071694061739E55",
"nickName": "高大上，牛逼吼吼吼吼吼"
}
]
}错误返回：
{
"state": false,
"message": "访问失败",
"data":"失败"
}这就没法玩了。。。。 会挨骂的。
避免层级过深的URI
/ 在url中表达层级，用于按实体关联关系进行对象导航，一般根据id导航。
过深的导航容易导致url膨胀，不易维护，如 GET /zoos/1/areas/3/animals/4，尽量使用查询参数代替路劲中的实体导航，如GET /animals?zoo=1&area=3。
结果过滤，排序，搜索
url最好越简短越好，对结果过滤、排序、搜索相关的功能都应该通过参数实现。
过滤：例如你想限制GET /tickets 的返回结果：只返回那些open状态的ticket， GET /tickets?state=open 这里的state就是过滤参数。
排序：和过滤一样，一个好的排序参数应该能够描述排序规则，而不和业务相关。复杂的排序规则应该通过组合实现。排序参数通过 , 分隔，排序参数前加 - 表示降序排列。
springboot06、log4j2日志配置
目录
3、在application.properties中引入log4j2的配置
前言：
日志接口(slf4j)
slf4j是对所有日志框架制定的一种规范、标准、接口，并不是一个框架的具体的实现，因为接口并不能独立使用，需要和具体的日志框架实现配合使用（如log4j、logback）。
接口用于定制规范，可以有多个实现，使用时是面向接口的（导入的包都是slf4j的包而不是具体某个日志框架中的包），即直接和接口交互，不直接使用实现，所以可以任意的更换实现而不用更改代码中的日志相关代码。
日志实现(log4j、logback、log4j2)
Log4j：Apache的一个开源项目，可以控制日志信息输送的目的地是控制台、文件、GUI组件等，可以控制每一条日志的输出格式，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。虽然已经停止维护了，但目前绝大部分企业都是用的log4j。
LogBack：logback同样是由log4j的作者设计完成的，拥有更好的特性，用来取代log4j的一个日志框架，是slf4j的原生实现。
Log4j2：Log4j2是log4j 1.x和logback的改进版，据说采用了一些新技术（无锁异步、等等），使得日志的吞吐量、性能比log4j 1.x提高10倍，并解决了一些死锁的bug，而且配置更加简单灵活。
1、pom配置
<!-- log4j2所需要的配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion><!-- springboot默认是用logback的日志框架的 -->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId
</exclusion>
</exclusions>
</dependency>
<dependency> <!-- 引入log4j2依赖 -->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>2、log4j2-spring.xml配置文件
我精简了配置，只输出到控制台。
<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数， 不设置默认5s
-->
<Configuration status="debug">
<!-- 配置日志信息输出 -->
<Appenders>
<!-- 输出到控制台， target属性一般为SYSTEM_OUT，也可以是 SYSTEM_ERR, -->
<Console name="Console" target="SYSTEM_OUT">
<!--配置日志信息的格式 -->
<PatternLayout pattern="%d{HH:mm:ss} [%t] %-5level %logger{36} - %msg%n" />
</Console>
</Appenders>
<!-- 定义logger,只有定义了logger并引入了appender,appender才会有效 -->
<Loggers>
<!-- 将业务dao接口所在的包填写进去,并用在控制台和文件中输出 此处配置的是mybatis的输出 level记得设置为debug -->
<logger name="com.item.dao.*" level="debug" additivity="false">
<AppenderRef ref="Console" />
</logger>
<Root level="info">
<AppenderRef ref="Console" />
</Root>
</Loggers>
</Configuration>3、在application.properties中引入log4j2的配置
# 引入log4j
logging.config=classpath:log4j2-spring.xml
# 控制台打印sql
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl4、log4j使用
包：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;声明：
private final Logger log = LoggerFactory.getLogger(this.getClass());使用：
log.info("访问模糊查询");效果：
springboot07、task定时任务
定时任务的概述
在项目中开发定时任务应该是一种比较常见的需求，在Java中开发定时任务主要有三种方案：一是使用JDK自带的Timer,二是使用第三方组件Quartz'，三是使用Spring Task。
Timer是JDK自带的定时任务工具，其简单易用，但是对于复杂的定时规则无法满足，在实际项目开发中也很少使用到，Quartz功能强大，但是使用起来相对笨重，而Spring Task则具备了前两者之间的优点，使用起来简单，除Spring 相关的包外不需要额外的包，而且支持注解和配置文件两种形式。
所以咱们这里使用springboot的task，相对方便、快捷、高效。
1、启动类上添加@EnableScheduling
package com.item;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableScheduling;
@MapperScan("com.item.dao")
@SpringBootApplication
@EnableScheduling
public class Action extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Action.class);
}
public static void main(String[] args) {
SpringApplication.run(Action.class,args);
}
}2、创建测试包【com.item.task】
2.1fixedRate定时
package com.item.task;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Date;
/**
* 任务类
*/
@Component
public class TaskTest {
/**
* 每2秒执行1次
*/
@Scheduled(fixedRate = 2000)
public void fixedRateMethod() throws InterruptedException {
System.out.println("task-fixedRate,每2秒执行1此:" + new Date());
Thread.sleep(1000);
}
}
2.2cron定时
package com.item.task;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 任务类
*/
@Component
public class TaskCron {
private SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
* 在每分钟的00秒执行
*/
@Scheduled(cron = "0 * * * * ?")
public void oneMin() throws InterruptedException {
System.out.println("cron每分钟执行:" + simpleDateFormat.format(new Date()));
}
/**
* 每5秒执行
*/
@Scheduled(cron = "*/5 * * * * ?")
public void fiveS() throws InterruptedException {
System.out.println("cron每5秒执行:" + simpleDateFormat.format(new Date()));
}
}
Cron表达式
cronExpression表达式有至少6个由空格分隔的时间元素，从左往右，这些元素的定义如下:
秒，分，时，月份中的日期，月份，星期，年份
字段 允许值 允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选） 留空, 1970-2099 , - * /* 表示所有值；
? 表示未说明的值，即不关心它为何值；
- 表示一个指定的范围；
, 表示附加一个可能值；
/ 符号前表示开始时间，符号后表示每次递增的值；
常用定时：
每隔5秒执行一次任务： "*/5 * * * * ?"
每隔1分钟执行一次任务： "0 */1 * * * ?"
每天23点执行一次任务： "0 0 23 * * ?"
每天凌晨1点执行一次任务： "0 0 1 * * ?"
每月1号凌晨1点执行一次任务： "0 0 1 1 * ?"
每月1号凌晨2点执行一次任务： "0 0 2 1 * ? *"
每月最后一天23点执行一次任务： "0 0 23 L * ?"
每周星期天凌晨1点执行一次任务： "0 0 1 ? * L"
每隔5秒执行一次任务： "*/5 * * * * ?"
每隔1分钟执行一次任务： "0 */1 * * * ?"
每天23点执行一次任务： "0 0 23 * * ?"
每天凌晨1点执行一次任务： "0 0 1 * * ?"
每月1号凌晨1点执行一次任务： "0 0 1 1 * ?"
每月1号凌晨2点执行一次任务： "0 0 2 1 * ? *"
每月最后一天23点执行一次任务： "0 0 23 L * ?"
每周星期天凌晨1点执行一次任务： "0 0 1 ? * L"效果：
springboot08、拦截器HandlerInterceptor
前言
拦截器这个名词定义的非常形象，就像导弹要攻击目标的时候，可能会被先进的反导系统拦截，此处的反导系统就是一种拦截器。
我们开发的应用，对外暴露的是控制器中定义的 API 方法，我们可以在 API 方法的外围放置拦截器，所有对 API 的访问都可以通过拦截器进行过滤。
OK，那么这样的拦截有什么意义吗，其实已经很明显了，反导系统可以保护目标的安全并识别对目标的攻击行为。同理，拦截器可以跟踪对应用的访问行为，对合法访问行为予以放行，对非法访问行为予以拒绝。怎么样，是不是很牛，接下来咱们就在 Spring Boot 项目中具体实现下。
1、创建拦截器【com.item.handler】
通过【request】可以获取任何值
package com.item.handler;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
/**
* 自定义拦截器类
*/
public class MyInterceptor implements HandlerInterceptor {// 实现HandlerInterceptor接口
/**
* （1） preHandle方法是进行处理器拦截用的，顾名思义，该方法将在Controller处理之前进行调用。
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println(new Date() + "--preHandle:" + request.getRequestURL());
StringBuffer url = request.getRequestURL();
if(url.substring(url.lastIndexOf("/")+1,url.length()).equals("GetName")){
System.out.println("------模糊查询方法------");
String nickName = request.getParameter("nickName");
System.out.println("获取的是nickName："+nickName+"，我可以根据获取的值判断是否是sql注入等操作");
}
return true;
}
/**
* 这个方法只会在当前这个Interceptor的preHandle方法返回值为true的时候才会执行。
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println(new Date() + "--postHandle:" + request.getRequestURL());
}
/**
* 该方法将在postHandle请求完成之后，也就是DispatcherServlet渲染了视图执行
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println(new Date() + "--afterCompletion:" + request.getRequestURL());
}
}
在上面的实例中，我们定义了一个拦截器类 MyInterceptor ，通过实现 HandlerInterceptor 接口，该类具备了拦截器的功能。
MyInterceptor 中的方法执行顺序为 preHandle – Controller 方法 – postHandle – afterCompletion ，所以拦截器实际上可以对 Controller 方法执行前后进行拦截监控。
最后还有一个非常重要的注意点， preHandle 需要返回布尔类型的值。 preHandle 返回 true 时，对控制器方法的请求才能到达控制器，继而到达 postHandle 和 afterCompletion 方法；如果 preHandle 返回 false ，后面的方法都不会执行。
2、生效配置【com.item.handler】内创建【WebConfig】
如果想让配置器生效，还需要通过配置类进行相应配置。
package com.item.handler;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* Web配置类
*/
@Configuration
public class WebConfig implements WebMvcConfigurer {
/**
* 添加Web项目的拦截器
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 对所有访问路径，都通过MyInterceptor类型的拦截器进行拦截
registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
}
}
3、拦截器效果：
4、拦截器作用
主要完成请求参数的解析、将页面表单参数赋给值栈中相应属性、执行功能检验、程序异常调试等工作，例如：登录校验、Token验证等。
springboot09、监控
前言
因为公司开发的项目多、为客户部署的项目实例多。工作中我们都会经常遇到，由于某个客户的项目突然无法访问，一堆研发、售后部门的同事火急火燎处理问题的场景。
- 能够有一个界面，监控所有关注的项目实例运行状态。
- 对于某个项目实例来说，可以监控该实例的各项运行参数，例如内存占用情况、磁盘使用情况、数据库连接情况。
利用 Spring Boot Admin 实现可视化监控，此时至少需要两个项目实例，一个是监控的管理端，一个是被监控的客户端。
注：会与swagger冲突。这个功能是在上线后使用，所以注意关闭swagger。
目录
1、pom配置
<!-- Spring Boot Admin 管理端依赖项 -->
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-server</artifactId>
<version>2.2.3</version>
</dependency>2、启动项配置
package com.item;
import de.codecentric.boot.admin.server.config.EnableAdminServer;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableScheduling;
@MapperScan("com.item.dao")
@SpringBootApplication
@EnableScheduling
@EnableAdminServer
public class Action extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Action.class);
}
public static void main(String[] args) {
SpringApplication.run(Action.class,args);
}
}3、访问主页
根据端口号访问就行【】
4、客户端pom依赖：
<!-- Spring Boot Admin监控客户端依赖 -->
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-client</artifactId>
<version>2.2.3</version>
</dependency>5、修改客户端配置
# 修改端口号避免冲突
server.port=8081
# 配置监控管理端地址
spring.boot.admin.client.url=http://127.0.0.1:8088
# 客户端的名称，用于区分不同的客户端
spring.boot.admin.client.instance.name=CLIENT1
# 配置客户端展示哪些信息，*表示展示全部信息
management.endpoints.web.exposure.include=*
启动client_test，可以看到应用是1了，可以多启动几个，都能看到
点击进去:
多弄几个效果还是很明显的。
springboot10、AOP
前言
Spring 最重要的两个功能，就是依赖注入和面向切面编程（AOP）。
AOP 为我们提供了处理问题的全局化视角，使用得当可以极大提高编程效率。
Spring Boot 中使用 AOP 与 Spring 中使用 AOP 几乎没有什么区别，只是建议尽量使用 Java 配置代替 XML 配置。
目录
1、pom依赖
<!-- AOP -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>2、AOP控制器【com.item.aop】
package com.item.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
/**
* 日志切面
*/
@Component
@Aspect // 标注为切面
public class LogAspect {
private Logger logger = LoggerFactory.getLogger(this.getClass());
// 切入点表达式，表示切入点为控制器包中的所有方法
@Pointcut("within(com.item.controller..*)")
public void LogAspect() {
}
// 切入点之前执行
@Before("LogAspect()")
public void doBefore(JoinPoint joinPoint) {
logger.info("访问时间：{}--访问接口:{}", new Date(), joinPoint.getSignature());
}
}
3、测试apo效果
可以根据返回的路径进行接口控制
4、使用 AOP 监控性能
在研发项目的性能测试阶段，或者项目部署后，我们会希望查看服务层方法执行的时间。以便精准的了解项目中哪些服务方法执行速度慢，后续可以针对性的进行性能优化。
此时我们就可以使用 AOP 的环绕通知，监控服务方法的执行时间。
package com.item.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 服务层方法切面
*/
@Component
@Aspect // 标注为切面
public class ServiceAspect {
private Logger logger = LoggerFactory.getLogger(this.getClass());
// 切入点表达式，表示切入点为服务层包中的所有方法
@Pointcut("within(com.item.controller..*)")
public void ServiceAspect() {
}
@Around("ServiceAspect()") // 环绕通知
public Object deAround(ProceedingJoinPoint joinPoint) throws Throwable {
long startTime = System.currentTimeMillis();// 记录开始时间
Object result = joinPoint.proceed();
logger.info("接口层方法:{}--执行时间:{}毫秒", joinPoint.getSignature(), System.currentTimeMillis() - startTime);
return result;
}
}
springboot11、redis
前言
redis可以说是现在最火的非关系型数据库，主要是它处理数据的能力是真的很强。就说win环境的处理能力一般的机器也能在每秒3万次以上，已经很厉害了。我们一般的几万用户的APP根本不需要集群，一个Redis即可搞定几乎所有的小规模并发性问题了。
资源地址：
目录
2、配置声明(application.properties中)
6、创建测试接口【com.item.controller】内
8、启动测试http://127.0.0.1:8088/swagger-ui.htm
1、pom依赖
<!-- Redis 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.1.0</version>
</dependency>2、配置声明(application.properties中)
#---------------------------------
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0
#---------------------------------3、编写配置文件【com.item.redis】
中间有输出语句就是为了表现配置成功，可以删掉。
package com.item.redis;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
/**
* 完成对Redis整合的配置
*/
@Configuration
public class RedisConfig {
/**
* 1.创建 JedisPoolConfig 对象。在该对象中完成一些链接池配置
*/
@Bean
@ConfigurationProperties(prefix = "spring.redis.jedis.pool")
public JedisPoolConfig JedisPoolConfig() {
JedisPoolConfig config = new JedisPoolConfig();
System.out.println("redis默认值：" + config.getMaxIdle());
System.out.println("redis默认值：" + config.getMinIdle());
System.out.println("redis默认值：" + config.getMaxTotal());
return config;
}
/**
* 2.创建 JedisConnectionFactory 对象，配置Redis连接属性
*
* @param config
* @return
*/
@Bean
@ConfigurationProperties(prefix = "spring.redis")
public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig config) {
System.out.println("redis配置完毕：" + config.getMaxIdle());
System.out.println("redis配置完毕：" + config.getMinIdle());
System.out.println("redis配置完毕：" + config.getMaxTotal());
JedisConnectionFactory factory = new JedisConnectionFactory();
factory.setPoolConfig(config);//关联连接池的配置对象
return factory;
}
/**
* 3.创建RedisTemplate，用于执行Redis操作的方法
*
* @param factory
* @return
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
//关联JedisConnectionFactory
template.setConnectionFactory(factory);
//为key序列化器
template.setKeySerializer(new StringRedisSerializer());
//为value设置序列化器
template.setValueSerializer(new StringRedisSerializer());
return template;
}
}4、操作提示
//通过依赖注入使用redis
@Autowired
private RedisTemplate redisTemplate;
redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForZSet();//操作有序set5、RedisBase编码(只包含字符串处理)
package com.item.redis;
import com.item.Base.RedisUrl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
public class RedisBase {
/**
* 返回的是Object
*/
@Autowired
private RedisTemplate redisTemplate;
/**
* 返回String
*/
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 添加值
* @param key
* @param value
* @return
*/
public boolean redisSet(String key,String value){
key= RedisUrl.url+key;
stringRedisTemplate.opsForValue().set(key,value);
String o = stringRedisTemplate.opsForValue().get(key);
return o==null?false:true;
}
/**
* 存储带倒计时的字符串
* @param key
* @param value
* @param second
* @return
*/
public boolean redisSetTime(String key,String value,long second){
key= RedisUrl.url+key;
stringRedisTemplate.opsForValue().set(key,value,second);
String s = stringRedisTemplate.opsForValue().get(key);
return s==null?false:true;
}
/**
* 获取key的value
* @param key
* @return
*/
public String redisGet(String key){
key= RedisUrl.url+key;
return stringRedisTemplate.opsForValue().get(key);
}
}
6、创建测试接口【com.item.controller】内
package com.item.controller;
import com.item.model.Users;
import com.item.redis.RedisBase;
import com.item.res.SUCCESS;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Api("用户操作接口")
@RestController
@CrossOrigin
@RequestMapping("Redis/")
public class RedisController extends RedisBase {
/**
* 测试Redis添加
*/
@GetMapping("SetRedis")
@ApiOperation(value = "添加key_value",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "key",required = true,paramType = "query",dataType = "String",value = "redis_key"),
@ApiImplicitParam(name = "value",required = true,paramType = "query",dataType = "String",value = "redis_value")
})
public Object testRedisSet(String key,String value){
redisSet(key,value);
return new SUCCESS("写入成功");
}
/**
* 测试Redis查询
*/
@GetMapping("GetRedis")
@ApiOperation(value = "获取key信息",notes = "没啥留言的")
@ApiImplicitParams({
@ApiImplicitParam(name = "key",required = true,paramType = "query",dataType = "String",value = "redis_key")
})
public Object testRedisGet(String key){
return new SUCCESS(redisGet(key));
}
}7、编写redis层级【com.item.Base】
package com.item.Base;
public class RedisUrl {
public static final String url="demo:infos:";
}
8、启动测试
能写入，能查询，没问题。
我个人喜欢用String和list，自己用自己封装吧。
【声明】本内容来自华为云开发者社区博主，不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息，否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）