sunny123456

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
springboot快速入门一篇文章全

springboot快速入门一篇文章全

springboot快速入门一篇文章全

 springboot01、基本配置

springboot简介

Spring Boot 为简化 Spring 应用开发而生，Spring Boot 中的 Boot 一词，即为快速启动的意思。Spring Boot 可以在零配置情况下一键启动，简洁而优雅。

为了让 Spring 开发者痛快到底，Spring 团队做了以下设计：

  • 简化依赖，提供整合的依赖项，告别逐一添加依赖项的烦恼；
  • 简化配置，提供约定俗成的默认配置，告别编写各种配置的繁琐；
  • 简化部署，内置 servlet 容器，开发时一键即运行。可打包为 jar 文件，部署时一行命令即启动；
  • 简化监控，提供简单方便的运行监控方式。

基于以上设计目的，Spring 团队推出了 Spring Boot 。

目录

1、pom.xml

2、项目层次

3、启动文件【com.item/Action.java】

4、controller文件

5、启动测试（数据是跨域的）

1、pom.xml

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.3.4.RELEASE</version>
  5. </parent>
  6. <dependencies>
  7.     <dependency>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-web</artifactId>
  10.     </dependency>
  11. </dependencies>

2、项目层次

3、启动文件【com.item/Action.java】

  1. package com.item;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5.  
  6. @SpringBootApplication
  7. public class Action {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(Action.class,args);//一定是被@SpringBootApplication标记的类
  10.     }
  11.  
  12. }

4、controller文件

其中@RestController = @Controller + @ResponseBody；

  1. package com.item.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.CrossOrigin;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.ResponseBody;
  7. import org.springframework.web.bind.annotation.RestController;
  8.  
  9. import java.util.HashMap;
  10.  
  11. @RestController
  12. @CrossOrigin
  13. public class UsersController {
  14.  
  15.     @GetMapping("GetInfo")
  16.     public Object GetInfo(){
  17.         HashMap<String,Object> map=new HashMap<String,Object>();
  18.         map.put("state",true);
  19.         map.put("msg","成功");
  20.         map.put("result","有一个字符串");
  21.         return map;
  22.     }
  23. }

5、启动测试（数据是跨域的）

访问路径：【http://127.0.0.1:8080/GetInfo】

 springboot02、打war包

Spring Boot 打包为 war 并运行

将 Spring Boot 打包为 war ，然后放置于 Tomcat 的 webapps 目录下加载运行，接下来我们就详细描述下打包为 war 的过程。

目录

1、修改打包方式

2、修改启动文件【Action.java】

3、打包命令

4、打包效果：

1、修改打包方式

在【pom.xml】文件中修改默认的打包方式，显式指定打包方式为 war。

  1. <name>demospring</name>
  2. <packaging>war</packaging>

由于 Spring Boot 内置了 Tomcat ，所以我们在打包时需要排除内置的 Tomcat ，这样可以避免内置 Tomcat 和 war 包部署运行的 Tomcat 产生冲突。在 pom.xml 中添加如下依赖即可：

  1. <!-- 阻断器·打包的是否排除内置的tomcat -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-tomcat</artifactId>
  5. </dependency>

2、修改启动文件【Action.java】

  1. package com.item;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.boot.builder.SpringApplicationBuilder;
  6. import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
  7.  
  8. @SpringBootApplication
  9. public class Action extends SpringBootServletInitializer {
  10.     @Override
  11.     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
  12.         return application.sources(Action.class);
  13.     }
  14.     public static void main(String[] args) {
  15.         SpringApplication.run(Action.class,args);//一定是被@SpringBootApplication标记的类
  16.     }
  17. }

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引包

2、数据源配置application.properties

3、model对应数据库的类Users

4、dao层·需要加上@Repository注解

5、添加映射文件UsersMapper.xml

6、service层编码

7、serviceimpl层编码

8、Controller层编码

9、测试效果：

1、pom引包

  1. 	   <dependency>
  2. 			<groupId>org.springframework.boot</groupId>
  3. 			<artifactId>spring-boot-starter</artifactId>
  4. 		</dependency>
  5. 		<!-- 热部署 -->
  6. 		<dependency>
  7. 			<groupId>org.springframework.boot</groupId>
  8. 			<artifactId>spring-boot-devtools</artifactId>
  9. 		</dependency>
  10. 		<!-- Web支持 -->
  11. 		<dependency>
  12. 			<groupId>org.springframework.boot</groupId>
  13. 			<artifactId>spring-boot-starter-web</artifactId>
  14. 		</dependency>
  15. 		<!-- JDBC -->
  16. 		<dependency>
  17. 			<groupId>org.springframework.boot</groupId>
  18. 			<artifactId>spring-boot-starter-jdbc</artifactId>
  19. 		</dependency>
  20. 		<!-- MySQL驱动 -->
  21. 		<dependency>
  22. 			<groupId>mysql</groupId>
  23. 			<artifactId>mysql-connector-java</artifactId>
  24. 		</dependency>
  25. 		<!-- 集成MyBatis -->
  26. 		<dependency>
  27. 			<groupId>org.mybatis.spring.boot</groupId>
  28. 			<artifactId>mybatis-spring-boot-starter</artifactId>
  29. 			<version>2.1.2</version>
  30. 		</dependency>
  31. 		<!-- junit -->
  32. 		<dependency>
  33. 			<groupId>junit</groupId>
  34. 			<artifactId>junit</artifactId>
  35. 			<scope>test</scope>
  36. 		</dependency>
  37. 		<!-- 测试 -->
  38. 		<dependency>
  39. 			<groupId>org.springframework.boot</groupId>
  40. 			<artifactId>spring-boot-starter-test</artifactId>
  41. 			<scope>test</scope>
  42. 			<exclusions>
  43. 				<exclusion>
  44. 					<groupId>org.junit.vintage</groupId>
  45. 					<artifactId>junit-vintage-engine</artifactId>
  46. 				</exclusion>
  47. 			</exclusions>
  48. 		</dependency>

2、数据源配置application.properties

Spring Boot 会将数据源自动注入到 MyBatis 的 sqlSessionFactory 组件中。对于我们开发者来说，这一切都是自动实现的，非常简单。

  1. # 配置数据库驱动
  2. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  3. # 配置数据库url
  4. spring.datasource.url=jdbc:mysql://rm-bp1zq3879r28p726lco.mysql.rds.aliyuncs.com:3306/test?characterEncoding=utf8
  5. # 配置数据库用户名
  6. spring.datasource.username=qwe8403000
  7. # 配置数据库密码
  8. spring.datasource.password=Qwe8403000
  9. # 指定MyBatis配置文件位置
  10. mybatis.mapper-locations=classpath:mapper/*.xml
  11. # 指定模型位置
  12. mybatis.typeAliasesPackage=com.item.model
  13. # 修改端口号避免冲突
  14. server.port=8088
  15. # 服务路径
  16. server.servlet.context-path=/demospring

3、model对应数据库的类Users

  1. package com.item.model;
  2.  
  3. public class Users {
  4.  
  5.     public int getId() {
  6.         return id;
  7.     }
  8.  
  9.     public void setId(int id) {
  10.         this.id = id;
  11.     }
  12.  
  13.     public String getUserName() {
  14.         return userName;
  15.     }
  16.  
  17.     public void setUserName(String userName) {
  18.         this.userName = userName;
  19.     }
  20.  
  21.     public String getPwd() {
  22.         return pwd;
  23.     }
  24.  
  25.     public void setPwd(String pwd) {
  26.         this.pwd = pwd;
  27.     }
  28.  
  29.     public String getNickName() {
  30.         return nickName;
  31.     }
  32.  
  33.     public void setNickName(String nickName) {
  34.         this.nickName = nickName;
  35.     }
  36.  
  37.     @Override
  38.     public String toString() {
  39.         return "Users{" +
  40.                 "id=" + id +
  41.                 ", userName='" + userName + '\'' +
  42.                 ", pwd='" + pwd + '\'' +
  43.                 ", nickName='" + nickName + '\'' +
  44.                 '}';
  45.     }
  46.  
  47.     private int id;
  48.     private String userName;
  49.     private String pwd;
  50.     private String nickName;
  51.  
  52. }

4、dao层·需要加上@Repository注解

  1. package com.item.dao;
  2.  
  3. import com.item.model.Users;
  4. import org.apache.ibatis.annotations.Param;
  5. import org.springframework.stereotype.Repository;
  6.  
  7. import java.util.List;
  8. /**
  9.  * 数据访问组件
  10.  */
  11. @Repository
  12. public interface UsersMapper {
  13.     List<Users> GetInfo();
  14.     List<Users> SelectName(@Param("nickName") String nickName);
  15.     Users UsersSelectById(@Param("id") int id);
  16.     int UsersAddInfo(
  17.             @Param("userName") String userName,
  18.             @Param("pwd") String pwd,
  19.             @Param("nickName") String nickName
  20.     );
  21.     int UsersUpdateInfo(
  22.             @Param("pwd") String pwd,
  23.             @Param("id") int id
  24.     );
  25.     int UsersDeleteById(@Param("id") int id);
  26. }

5、添加映射文件UsersMapper.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.item.dao.UsersMapper">
  4.     <!-- 用作基础查询测试 -->
  5.     <select id="GetInfo" resultType="Users">
  6.         select * from users
  7.     </select>
  8.     <!-- 用做传递参数测试 -->
  9.     <select id="SelectName" resultType="Users">
  10.         select * from users where nickName like "%${nickName}%"
  11.     </select>
  12.     <!-- id精准查询 -->
  13.     <select id="UsersSelectById" resultType="Users">
  14.         select * from users where id=#{id}
  15.     </select>
  16.     <!-- 增加 -->
  17.     <insert id="UsersAddInfo">
  18.         insert into users values(0,"${userName}","${pwd}","${nickName}");
  19.     </insert>
  20.     <!-- 修改 -->
  21.     <update id="UsersUpdateInfo">
  22.         update users set pwd="${pwd}" where id=#{id}
  23.     </update>
  24.     <!-- 删除 -->
  25.     <delete id="UsersDeleteById">
  26.         delete from users where id=#{id}
  27.     </delete>
  28. </mapper>

6、service层编码

  1. package com.item.service;
  2.  
  3. import com.item.model.Users;
  4.  
  5. import java.util.List;
  6.  
  7. public interface UsersService {
  8.     /**
  9.      * 获取所有
  10.      * @return
  11.      */
  12.     List<Users> GetInfo();
  13.  
  14.     /**
  15.      * 获取nickName的模糊查询结果集
  16.      * @param nickName
  17.      * @return
  18.      */
  19.     List<Users> SelectName(String nickName);
  20.  
  21.     /**
  22.      * id精准查询
  23.      * @param id
  24.      * @return
  25.      */
  26.     Users UsersSelectById(int id);
  27.  
  28.     /**
  29.      * 添加信息
  30.      * @param userName
  31.      * @param pwd
  32.      * @param nickName
  33.      * @return
  34.      */
  35.     int UsersAddInfo(
  36.             String userName,
  37.             String pwd,
  38.             String nickName
  39.     );
  40.  
  41.     /**
  42.      * 修改密码
  43.      * @param pwd
  44.      * @param id
  45.      * @return
  46.      */
  47.     int UsersUpdateInfo(
  48.             String pwd,
  49.             int id
  50.     );
  51.  
  52.     /**
  53.      * 删除信息
  54.      * @param id
  55.      * @return
  56.      */
  57.     int UsersDeleteById(int id);
  58. }

7、serviceimpl层编码

  1. package com.item.serviceimpl;
  2.  
  3. import com.item.dao.UsersMapper;
  4. import com.item.model.Users;
  5. import com.item.service.UsersService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.util.DigestUtils;
  9.  
  10. import java.io.UnsupportedEncodingException;
  11. import java.security.MessageDigest;
  12. import java.security.NoSuchAlgorithmException;
  13. import java.util.List;
  14.  
  15. @Service
  16. public class UsersServiceImpl implements UsersService {
  17.     @Autowired
  18.     private UsersMapper usersMapper;
  19.  
  20.     @Override
  21.     public List<Users> GetInfo() {
  22.         return usersMapper.GetInfo();
  23.     }
  24.  
  25.     @Override
  26.     public List<Users> SelectName(String nickName) {
  27.         return usersMapper.SelectName(nickName);
  28.     }
  29.  
  30.     @Override
  31.     public Users UsersSelectById(int id) {
  32.         return usersMapper.UsersSelectById(id);
  33.     }
  34.  
  35.     @Override
  36.     public int UsersAddInfo(String userName, String pwd, String nickName) {
  37.         pwd=encrypt(pwd);
  38.         return usersMapper.UsersAddInfo(userName, pwd, nickName);
  39.     }
  40.  
  41.     @Override
  42.     public int UsersUpdateInfo(String pwd, int id) {
  43.         pwd=encrypt(pwd);
  44.         return usersMapper.UsersUpdateInfo(pwd, id);
  45.     }
  46.  
  47.     /**
  48.      * MD5加密
  49.      * @param password
  50.      * @return
  51.      */
  52.     private String encrypt(String password) {
  53.         String passwordMd5 = null;
  54.         try {
  55.             MessageDigest md5 = MessageDigest.getInstance("MD5");
  56.             byte[] bytes = md5.digest(password.getBytes("utf-8"));
  57.             passwordMd5 = toHex(bytes);
  58.         } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
  59.             e.printStackTrace();
  60.         }
  61.         return passwordMd5;
  62.     }
  63.  
  64.     private static String toHex(byte[] bytes) {
  65.         final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();
  66.         StringBuilder ret = new StringBuilder(bytes.length * 2);
  67.         for (int i = 0; i < bytes.length; i++) {
  68.             ret.append(HEX_DIGITS[(bytes[i] >> 4) & 0x0f]);
  69.             ret.append(HEX_DIGITS[bytes[i] & 0x0f]);
  70.         }
  71.         return ret.toString();
  72.     }
  73.  
  74.     @Override
  75.     public int UsersDeleteById(int id) {
  76.         return usersMapper.UsersDeleteById(id);
  77.     }
  78. }

8、Controller层编码

  1. package com.item.controller;
  2.  
  3. import com.item.model.Users;
  4. import com.item.service.UsersService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.ui.Model;
  7. import org.springframework.web.bind.annotation.*;
  8.  
  9. import javax.servlet.http.HttpServletRequest;
  10. import java.util.HashMap;
  11. import java.util.List;
  12.  
  13. @RestController
  14. @CrossOrigin
  15. public class UsersController {
  16.     @Autowired
  17.     private UsersService usersService;
  18.  
  19.     @GetMapping("/GetInfoApi")
  20.     public Object GetInfoApi(){
  21.         List<Users> list=usersService.GetInfo();
  22.         HashMap<String,Object> map=new HashMap<String,Object>();
  23.         map.put("state",true);
  24.         map.put("msg","成功");
  25.         map.put("result",list);
  26.         return map;
  27.     }
  28.  
  29.     @GetMapping("/GetName")
  30.     public Object GetName(HttpServletRequest request,Model model){
  31.         String nickName = request.getParameter("nickName");
  32.         List<Users> list=usersService.SelectName(nickName);
  33.         HashMap<String,Object> map=new HashMap<String,Object>();
  34.         map.put("state",true);
  35.         map.put("msg","成功");
  36.         map.put("result",list);
  37.         return map;
  38.     }
  39.  
  40.     /**
  41.      * 添加接口，访问方式post
  42.      * @param request
  43.      * @param model
  44.      * @return
  45.      */
  46.     @PostMapping(value = "/UserAddInfoApi")
  47.     public Object UserAddInfoApi(HttpServletRequest request,Model model){
  48.         String userName = request.getParameter("userName");
  49.         String pwd = request.getParameter("pwd");
  50.         String nickName = request.getParameter("nickName");
  51.         usersService.UsersAddInfo(userName, pwd, nickName);
  52.         HashMap<String,Object> map=new HashMap<String,Object>();
  53.         map.put("state",true);
  54.         map.put("msg","成功");
  55.         map.put("result","");
  56.         return map;
  57.     }
  58.  
  59.     /**
  60.      * 单个查询
  61.      * @param request
  62.      * @param model
  63.      * @return
  64.      */
  65.     @GetMapping("/UsersSelectById")
  66.     public Object UsersSelectById(HttpServletRequest request,Model model){
  67.         String id = request.getParameter("id");
  68.         Users users = usersService.UsersSelectById(Integer.parseInt(id));
  69.         HashMap<String,Object> map=new HashMap<String,Object>();
  70.         map.put("state",true);
  71.         map.put("msg","成功");
  72.         map.put("result",users);
  73.         return map;
  74.     }
  75.  
  76.     /**
  77.      * 修改api
  78.      * @param request
  79.      * @param model
  80.      * @return
  81.      */
  82.     @PostMapping(value = "/UserUpdateInfoApi")
  83.     public Object UserUpdateInfoApi(HttpServletRequest request,Model model){
  84.         String id = request.getParameter("id");
  85.         String pwd = request.getParameter("pwd");
  86.         usersService.UsersUpdateInfo(pwd,Integer.parseInt(id));
  87.         HashMap<String,Object> map=new HashMap<String,Object>();
  88.         map.put("state",true);
  89.         map.put("msg","成功");
  90.         map.put("result","");
  91.         return map;
  92.     }
  93.  
  94.     /**
  95.      * 删除api
  96.      * @param request
  97.      * @param model
  98.      * @return
  99.      */
  100.     @GetMapping(value = "/UsersDeleteById")
  101.     public Object UsersDeleteById(HttpServletRequest request,Model model){
  102.         String id = request.getParameter("id");
  103.         usersService.UsersDeleteById(Integer.parseInt(id));
  104.         HashMap<String,Object> map=new HashMap<String,Object>();
  105.         map.put("state",true);
  106.         map.put("msg","成功");
  107.         map.put("result","");
  108.         return map;
  109.     }
  110. }

备注：dao层引入

  1. package com.item;
  2.  
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.boot.builder.SpringApplicationBuilder;
  7. import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
  8. @MapperScan("com.item.dao")
  9. @SpringBootApplication
  10. public class Action extends SpringBootServletInitializer {
  11.     @Override
  12.     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
  13.         return application.sources(Action.class);
  14.     }
  15.     public static void main(String[] args) {
  16.         SpringApplication.run(Action.class,args);//一定是被@SpringBootApplication标记的类
  17.     }
  18. }

9、测试效果：

可以使用postman测试：

效果很明显，成功了。

StringUtils判断字符串是否为空

 可以直接看到测试效果，无论是null还是""都是空。

StringUtils依赖包：

  1. <!-- 判断字符串是否为空 -->
  2. <dependency>
  3.     <groupId>org.apache.commons</groupId>
  4.     <artifactId>commons-lang3</artifactId>
  5.     <version>3.8.1</version>
  6. </dependency>

StringUtils测试编码：

  1. import org.apache.commons.lang3.StringUtils;
  2.  
  3. public class Action {
  4.     public static void main(String[] args) {
  5.         String a=null;
  6.         String b="";
  7.         if(StringUtils.isEmpty(a)){
  8.             System.out.println("a空");
  9.         }
  10.         if(StringUtils.isEmpty(b)){
  11.             System.out.println("b空");
  12.         }
  13.     }
  14. }

StringUtils测试效果：

 springboot04、swagger配置

前言：

springboot的swagger配置与SSM稍微有些不同，SSM对2.9.0以上的兼容性很差，但是springboot就可以使用2.9.0以上的包了，其实区别不算太大，除了能对对象直接操作外就是页面更清爽了。

目录

1、pom依赖

2、swagger配置文件

3、接口api写法

4、启动效果：【http://127.0.0.1:8088/swagger-ui.html】

5、使用方法

​编辑

6、可能出现的异常总结：

1、pom依赖

  1. <!-- swagger包这里2.9.2 -->
  2. <dependency>
  3.     <groupId>io.springfox</groupId>
  4.     <artifactId>springfox-swagger2</artifactId>
  5.     <version>2.9.2</version>
  6. </dependency>
  7. <dependency>
  8.     <groupId>io.springfox</groupId>
  9.     <artifactId>springfox-swagger-ui</artifactId>
  10.     <version>2.9.2</version>
  11. </dependency>

2、swagger配置文件

这里单独创建了一个包【com.item.swagger】来放置swagger的配置文件

需要注意的是：【com.item.controller】这里需要改成自己的包位置。

  1. package com.item.swagger;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import springfox.documentation.builders.ApiInfoBuilder;
  8. import springfox.documentation.builders.PathSelectors;
  9. import springfox.documentation.builders.RequestHandlerSelectors;
  10. import springfox.documentation.service.ApiInfo;
  11. import springfox.documentation.service.Contact;
  12. import springfox.documentation.spi.DocumentationType;
  13. import springfox.documentation.spring.web.plugins.Docket;
  14. import springfox.documentation.swagger2.annotations.EnableSwagger2;
  15.  
  16. @Configuration
  17. @EnableSwagger2
  18. public class SwaggerConfig {
  19.     private static Logger log = LoggerFactory.getLogger(SwaggerConfig.class);
  20.     @Bean
  21.     public Docket createRestApi() {
  22.         log.info("进入到swagger的配置中");
  23.         return new Docket(DocumentationType.SWAGGER_2)
  24.                 // 指定构建api文档的详细信息的方法：apiInfo()
  25.                 .apiInfo(apiInfo())
  26.                 .groupName("红目香薰")
  27.                 .select()
  28.                 // 指定要生成api接口的包路径，这里把controller作为包路径，生成controller中的所有接口
  29.                 .apis(RequestHandlerSelectors.basePackage("com.item.controller"))
  30.                 .paths(PathSelectors.any())
  31.                 .build();
  32.     }
  33.  
  34.     /**
  35.      * 构建api文档的详细信息
  36.      * @return
  37.      */
  38.     private ApiInfo apiInfo() {
  39.         return new ApiInfoBuilder()
  40.                 // 设置页面标题
  41.                 .title("Spring Boot集成Swagger2接口总览")
  42.                 // 设置接口描述
  43.                 .description("Swagger接口")
  44.                 // 设置联系方式
  45.                 .contact(new Contact("测试swagger","http://localhost:8080/",""))
  46.                 // 设置版本
  47.                 .version("1.0")
  48.                 // 构建
  49.                 .build();
  50.     }
  51.  
  52. }

3、接口api写法

我写了一套的注释方法，一目了然

  1. package com.item.controller;
  2.  
  3. import com.item.model.Users;
  4. import com.item.service.UsersService;
  5. import io.swagger.annotations.Api;
  6. import io.swagger.annotations.ApiImplicitParam;
  7. import io.swagger.annotations.ApiImplicitParams;
  8. import io.swagger.annotations.ApiOperation;
  9. import org.apache.commons.lang3.StringUtils;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.ui.Model;
  12. import org.springframework.web.bind.annotation.*;
  13.  
  14. import javax.servlet.http.HttpServletRequest;
  15. import java.util.HashMap;
  16. import java.util.List;
  17. @Api("用户操作接口")
  18. @RestController
  19. @CrossOrigin
  20. public class UsersController {
  21.     @Autowired
  22.     private UsersService usersService;
  23.  
  24.     /**
  25.      * 获取所有信息
  26.      * @return
  27.      */
  28.     @GetMapping("/GetInfoApi")
  29.     @ApiOperation(value = "获取信息",notes = "没啥留言的")
  30.     public Object GetInfoApi(){
  31.         List<Users> list=usersService.GetInfo();
  32.         HashMap<String,Object> map=new HashMap<String,Object>();
  33.         map.put("state",true);
  34.         map.put("msg","成功");
  35.         map.put("result",list);
  36.         return map;
  37.     }
  38.  
  39.     @GetMapping("/GetName")
  40.     @ApiOperation(value = "获取信息",notes = "没啥留言的")
  41.     @ApiImplicitParams({
  42.             @ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "通过昵称模糊查询")
  43.     })
  44.     public Object GetName(HttpServletRequest request,Model model){
  45.         String nickName = request.getParameter("nickName");
  46.         List<Users> list=usersService.SelectName(nickName);
  47.         HashMap<String,Object> map=new HashMap<String,Object>();
  48.         map.put("state",true);
  49.         map.put("msg","成功");
  50.         map.put("result",list);
  51.         return map;
  52.     }
  53.  
  54.     /**
  55.      * 添加信息
  56.      * @param userName
  57.      * @param pwd
  58.      * @param nickName
  59.      * @return
  60.      */
  61.     @PostMapping(value = "/UserAddInfoApi")
  62.     @ApiOperation(value = "添加",notes = "没啥留言的")
  63.     @ApiImplicitParams({
  64.             @ApiImplicitParam(name = "userName",required = true,paramType = "query",dataType = "String",value = "用户名"),
  65.             @ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
  66.             @ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "昵称")
  67.     })
  68.     public Object UserAddInfoApi(String userName,String pwd,String nickName){
  69.         HashMap<String,Object> map=new HashMap<String,Object>();
  70.         if(
  71.                 StringUtils.isEmpty(userName)||
  72.                 StringUtils.isEmpty(pwd)||
  73.                 StringUtils.isEmpty(nickName)
  74.         ){
  75.             map.put("state",false);
  76.             map.put("msg","参数不润许为空");
  77.             map.put("result","");
  78.             return map;
  79.         }
  80.         usersService.UsersAddInfo(userName, pwd, nickName);
  81.         map.put("state",true);
  82.         map.put("msg","成功");
  83.         map.put("result","");
  84.         return map;
  85.     }
  86.  
  87.     /**
  88.      * 单个查询
  89.      * @param id
  90.      * @return
  91.      */
  92.     @GetMapping("/UsersSelectById")
  93.     @ApiOperation(value = "id查询",notes = "没啥留言的")
  94.     @ApiImplicitParams({
  95.             @ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
  96.     })
  97.     public Object UsersSelectById(String id){
  98.         Users users = usersService.UsersSelectById(Integer.parseInt(id));
  99.         HashMap<String,Object> map=new HashMap<String,Object>();
  100.         map.put("state",true);
  101.         map.put("msg","成功");
  102.         map.put("result",users);
  103.         return map;
  104.     }
  105.  
  106.     /**
  107.      * 修改api
  108.      * @param id
  109.      * @param pwd
  110.      * @return
  111.      */
  112.     @PostMapping(value = "/UserUpdateInfoApi")
  113.     @ApiOperation(value = "添加",notes = "没啥留言的")
  114.     @ApiImplicitParams({
  115.             @ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号"),
  116.             @ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
  117.     })
  118.     public Object UserUpdateInfoApi(String id,String pwd){
  119.         usersService.UsersUpdateInfo(pwd,Integer.parseInt(id));
  120.         HashMap<String,Object> map=new HashMap<String,Object>();
  121.         map.put("state",true);
  122.         map.put("msg","成功");
  123.         map.put("result","");
  124.         return map;
  125.     }
  126.  
  127.     /**
  128.      * 删除api
  129.      * @param id
  130.      * @return
  131.      */
  132.     @GetMapping(value = "/UsersDeleteById")
  133.     @ApiOperation(value = "根据id删除",notes = "没啥留言的")
  134.     @ApiImplicitParams({
  135.             @ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
  136.     })
  137.     public Object UsersDeleteById(String id){
  138.         usersService.UsersDeleteById(Integer.parseInt(id));
  139.         HashMap<String,Object> map=new HashMap<String,Object>();
  140.         map.put("state",true);
  141.         map.put("msg","成功");
  142.         map.put("result","");
  143.         return map;
  144.     }
  145. }

4、启动效果：【http://127.0.0.1:8088/swagger-ui.html】

这里为了看着方便，我将服务路径改为了【/】

  1. # 服务路径
  2. server.servlet.context-path=/

5、使用方法

POST的也类似

6、可能出现的异常总结：

1、SwaggerConfig的配置文件中忘记写注解，就2个注解：

  1. @Configuration
  2. @EnableSwagger2

2、接口中的注解：

  1. @Api("用户操作接口")
  2. @ApiOperation(value = "获取信息",notes = "没啥留言的")
  3. @ApiImplicitParams({
  4.       @ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "通过昵称模糊查询")
  5. })

3、没有明确接口的访问类型，导致出现一堆的同名不同访问类型的接口提示。

使用@GetMapping或者@PostMapping就可以解决此问题。

 springboot05、封装结果集

不可能一直用map写数据返回，很麻烦的，那么咱们就可以进行一次封装此次使用。

目录

springboot05、封装结果集

创建【com.item.res】包

注意问题

编辑一个SUCCESS类和ERROR类，他们都有state、msg、result，那么就创建一个公用的父类base。

创建【com.item.res】包

Base：

  1. package com.item.res;
  2.  
  3. public class BASE {
  4.     private boolean state;
  5.     private String msg;
  6.     private Object result;
  7.  
  8.     public BASE(boolean state, String msg, Object result) {
  9.         this.state = state;
  10.         this.msg = msg;
  11.         this.result = result;
  12.     }
  13.  
  14.     public boolean isState() {
  15.         return state;
  16.     }
  17.  
  18.     public void setState(boolean state) {
  19.         this.state = state;
  20.     }
  21.  
  22.     public String getMsg() {
  23.         return msg;
  24.     }
  25.  
  26.     public void setMsg(String msg) {
  27.         this.msg = msg;
  28.     }
  29.  
  30.     public Object getResult() {
  31.         return result;
  32.     }
  33.  
  34.     public void setResult(Object result) {
  35.         this.result = result;
  36.     }
  37. }

ERROR：

  1. package com.item.res;
  2.  
  3. public class ERROR extends BASE {
  4.  
  5.     public ERROR(String msg, Object result) {
  6.         super(false, msg, result);
  7.     }
  8. }

SUCCESS：

  1. package com.item.res;
  2.  
  3. public class SUCCESS extends BASE {
  4.     public SUCCESS(Object result) {
  5.         super(false, "操作成功", result);
  6.     }
  7. }

返回修改：

  1. package com.item.controller;
  2.  
  3. import com.item.model.Users;
  4. import com.item.res.ERROR;
  5. import com.item.res.SUCCESS;
  6. import com.item.service.UsersService;
  7. import io.swagger.annotations.Api;
  8. import io.swagger.annotations.ApiImplicitParam;
  9. import io.swagger.annotations.ApiImplicitParams;
  10. import io.swagger.annotations.ApiOperation;
  11. import org.apache.commons.lang3.StringUtils;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.ui.Model;
  14. import org.springframework.web.bind.annotation.*;
  15.  
  16. import javax.servlet.http.HttpServletRequest;
  17. import java.util.HashMap;
  18. import java.util.List;
  19. @Api("用户操作接口")
  20. @RestController
  21. @CrossOrigin
  22. public class UsersController {
  23.     @Autowired
  24.     private UsersService usersService;
  25.  
  26.     /**
  27.      * 获取所有信息
  28.      * @return
  29.      */
  30.     @GetMapping("/GetInfoApi")
  31.     @ApiOperation(value = "获取信息",notes = "没啥留言的")
  32.     public Object GetInfoApi(){
  33.         List<Users> list=usersService.GetInfo();
  34.         return new SUCCESS(list);
  35.     }
  36.  
  37.     @GetMapping("/GetName")
  38.     @ApiOperation(value = "获取信息",notes = "没啥留言的")
  39.     @ApiImplicitParams({
  40.             @ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "通过昵称模糊查询")
  41.     })
  42.     public Object GetName(HttpServletRequest request,Model model){
  43.         String nickName = request.getParameter("nickName");
  44.         List<Users> list=usersService.SelectName(nickName);
  45.         return new SUCCESS(list);
  46.     }
  47.  
  48.     /**
  49.      * 添加信息
  50.      * @param userName
  51.      * @param pwd
  52.      * @param nickName
  53.      * @return
  54.      */
  55.     @PostMapping(value = "/UserAddInfoApi")
  56.     @ApiOperation(value = "添加",notes = "没啥留言的")
  57.     @ApiImplicitParams({
  58.             @ApiImplicitParam(name = "userName",required = true,paramType = "query",dataType = "String",value = "用户名"),
  59.             @ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
  60.             @ApiImplicitParam(name = "nickName",required = true,paramType = "query",dataType = "String",value = "昵称")
  61.     })
  62.     public Object UserAddInfoApi(String userName,String pwd,String nickName){
  63.         HashMap<String,Object> map=new HashMap<String,Object>();
  64.         if(
  65.                 StringUtils.isEmpty(userName)||
  66.                 StringUtils.isEmpty(pwd)||
  67.                 StringUtils.isEmpty(nickName)
  68.         ){
  69.             return new ERROR("参数为空","参数错误");
  70.         }
  71.         usersService.UsersAddInfo(userName, pwd, nickName);
  72.         return new SUCCESS("添加成功");
  73.     }
  74.  
  75.     /**
  76.      * 单个查询
  77.      * @param id
  78.      * @return
  79.      */
  80.     @GetMapping("/UsersSelectById")
  81.     @ApiOperation(value = "id查询",notes = "没啥留言的")
  82.     @ApiImplicitParams({
  83.             @ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
  84.     })
  85.     public Object UsersSelectById(String id){
  86.         Users users = usersService.UsersSelectById(Integer.parseInt(id));
  87.         HashMap<String,Object> map=new HashMap<String,Object>();
  88.         map.put("state",true);
  89.         map.put("msg","成功");
  90.         map.put("result",users);
  91.         return map;
  92.     }
  93.  
  94.     /**
  95.      * 修改api
  96.      * @param id
  97.      * @param pwd
  98.      * @return
  99.      */
  100.     @PostMapping(value = "/UserUpdateInfoApi")
  101.     @ApiOperation(value = "添加",notes = "没啥留言的")
  102.     @ApiImplicitParams({
  103.             @ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号"),
  104.             @ApiImplicitParam(name = "pwd",required = true,paramType = "query",dataType = "String",value = "密码"),
  105.     })
  106.     public Object UserUpdateInfoApi(String id,String pwd){
  107.         usersService.UsersUpdateInfo(pwd,Integer.parseInt(id));
  108.         HashMap<String,Object> map=new HashMap<String,Object>();
  109.         map.put("state",true);
  110.         map.put("msg","成功");
  111.         map.put("result","");
  112.         return map;
  113.     }
  114.  
  115.     /**
  116.      * 删除api
  117.      * @param id
  118.      * @return
  119.      */
  120.     @GetMapping(value = "/UsersDeleteById")
  121.     @ApiOperation(value = "根据id删除",notes = "没啥留言的")
  122.     @ApiImplicitParams({
  123.             @ApiImplicitParam(name = "id",required = true,paramType = "query",dataType = "String",value = "编号")
  124.     })
  125.     public Object UsersDeleteById(String id){
  126.         usersService.UsersDeleteById(Integer.parseInt(id));
  127.         HashMap<String,Object> map=new HashMap<String,Object>();
  128.         map.put("state",true);
  129.         map.put("msg","成功");
  130.         map.put("result","");
  131.         return map;
  132.     }
  133. }

使用swagger访问测试返回效果如下：

设置完成。 

注意问题：

每个人的习惯方式均不同，需要看看公司具体用什么方式：

也可能是这样返回：

{

“code”: -9999,

“message”: “Invalid Request”,

“data”:{ }

}

注意：无论是【ERROR】还是【SUCCESS】他们的返回结果都需要一致，否则前端在处理的时候就会很麻烦，对是一套解析，错又是一套解析，很麻烦。

例如：

正确返回:

  1. {
  2.  
  3. "state": true,
  4.  
  5. "message": "访问成功",
  6.  
  7. "data":
  8.  
  9. [
  10.     {
  11.       "id": 77,
  12.       "userName": "子玉等于摸鱼",
  13.       "pwd": "074FD28EFF0F5ADEA071694061739E55",
  14.       "nickName": "高大上，牛逼吼吼吼吼吼"
  15.     }
  16.   ]
  17. }

错误返回：

  1. {
  2.  
  3. "state": false,
  4.  
  5. "message": "访问失败",
  6.  
  7. "data":"失败"
  8. }

这就没法玩了。。。。 会挨骂的。

避免层级过深的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日志配置

目录

前言：

1、pom配置

2、log4j2-spring.xml配置文件

3、在application.properties中引入log4j2的配置

4、log4j使用

前言：

日志接口(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配置

  1. <!-- log4j2所需要的配置 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter</artifactId>
  5.     <exclusions>
  6.         <exclusion><!-- springboot默认是用logback的日志框架的 -->
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-logging</artifactId
  9.         </exclusion>
  10.     </exclusions>
  11. </dependency>
  12. <dependency> <!-- 引入log4j2依赖 -->
  13.     <groupId>org.springframework.boot</groupId>
  14.     <artifactId>spring-boot-starter-log4j2</artifactId>
  15. </dependency>

2、log4j2-spring.xml配置文件

我精简了配置，只输出到控制台。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
  3. <!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
  4. <!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数， 不设置默认5s
  5. -->
  6. <Configuration status="debug">
  7.     <!-- 配置日志信息输出 -->
  8.     <Appenders>
  9.         <!-- 输出到控制台， target属性一般为SYSTEM_OUT，也可以是 SYSTEM_ERR, -->
  10.         <Console name="Console" target="SYSTEM_OUT">
  11.             <!--配置日志信息的格式 -->
  12.             <PatternLayout pattern="%d{HH:mm:ss} [%t] %-5level %logger{36} - %msg%n" />
  13.         </Console>
  14.     </Appenders>
  15.     <!-- 定义logger,只有定义了logger并引入了appender,appender才会有效 -->
  16.     <Loggers>
  17.         <!-- 将业务dao接口所在的包填写进去,并用在控制台和文件中输出 此处配置的是mybatis的输出 level记得设置为debug -->
  18.         <logger name="com.item.dao.*" level="debug" additivity="false">
  19.             <AppenderRef ref="Console" />
  20.         </logger>
  21.         <Root level="info">
  22.             <AppenderRef ref="Console" />
  23.         </Root>
  24.     </Loggers>
  25. </Configuration>

3、在application.properties中引入log4j2的配置

  1. # 引入log4j
  2. logging.config=classpath:log4j2-spring.xml
  3. # 控制台打印sql
  4. mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

4、log4j使用

包：

  1. import org.slf4j.Logger;
  2. 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

  1. package com.item;
  2.  
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.boot.builder.SpringApplicationBuilder;
  7. import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
  8. import org.springframework.scheduling.annotation.EnableScheduling;
  9.  
  10. @MapperScan("com.item.dao")
  11. @SpringBootApplication
  12. @EnableScheduling
  13. public class Action extends SpringBootServletInitializer {
  14.     @Override
  15.     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
  16.         return application.sources(Action.class);
  17.     }
  18.     public static void main(String[] args) {
  19.         SpringApplication.run(Action.class,args);
  20.     }
  21. }

2、创建测试包【com.item.task】

2.1fixedRate定时

  1. package com.item.task;
  2.  
  3. import org.springframework.scheduling.annotation.Scheduled;
  4. import org.springframework.stereotype.Component;
  5.  
  6. import java.util.Date;
  7.  
  8. /**
  9.  * 任务类
  10.  */
  11. @Component
  12. public class TaskTest {
  13.     /**
  14.      * 每2秒执行1次
  15.      */
  16.     @Scheduled(fixedRate = 2000)
  17.     public void fixedRateMethod() throws InterruptedException {
  18.         System.out.println("task-fixedRate,每2秒执行1此:" + new Date());
  19.         Thread.sleep(1000);
  20.     }
  21. }

2.2cron定时

  1. package com.item.task;
  2. import org.springframework.scheduling.annotation.Scheduled;
  3. import org.springframework.stereotype.Component;
  4.  
  5. import java.text.SimpleDateFormat;
  6. import java.util.Date;
  7.  
  8. /**
  9.  * 任务类
  10.  */
  11. @Component
  12. public class TaskCron {
  13.     private SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  14.  
  15.     /**
  16.      * 在每分钟的00秒执行
  17.      */
  18.     @Scheduled(cron = "0 * * * * ?")
  19.     public void oneMin() throws InterruptedException {
  20.         System.out.println("cron每分钟执行:" + simpleDateFormat.format(new Date()));
  21.     }
  22.     /**
  23.      * 每5秒执行
  24.      */
  25.     @Scheduled(cron = "*/5 * * * * ?")
  26.     public void fiveS() throws InterruptedException {
  27.         System.out.println("cron每5秒执行:" + simpleDateFormat.format(new Date()));
  28.     }
  29. }

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"

  1. 每隔5秒执行一次任务：  "*/5 * * * * ?"
  2.  
  3. 每隔1分钟执行一次任务：  "0 */1 * * * ?"
  4.  
  5. 每天23点执行一次任务：  "0 0 23 * * ?"
  6.  
  7. 每天凌晨1点执行一次任务：  "0 0 1 * * ?"
  8.  
  9. 每月1号凌晨1点执行一次任务：  "0 0 1 1 * ?"
  10.  
  11. 每月1号凌晨2点执行一次任务：  "0 0 2 1 * ? *"
  12.  
  13. 每月最后一天23点执行一次任务：  "0 0 23 L * ?"
  14.  
  15. 每周星期天凌晨1点执行一次任务：  "0 0 1 ? * L"

效果：

springboot08、拦截器HandlerInterceptor

前言

拦截器这个名词定义的非常形象，就像导弹要攻击目标的时候，可能会被先进的反导系统拦截，此处的反导系统就是一种拦截器。

我们开发的应用，对外暴露的是控制器中定义的 API 方法，我们可以在 API 方法的外围放置拦截器，所有对 API 的访问都可以通过拦截器进行过滤。

OK，那么这样的拦截有什么意义吗，其实已经很明显了，反导系统可以保护目标的安全并识别对目标的攻击行为。同理，拦截器可以跟踪对应用的访问行为，对合法访问行为予以放行，对非法访问行为予以拒绝。怎么样，是不是很牛，接下来咱们就在 Spring Boot 项目中具体实现下。

1、创建拦截器【com.item.handler】

通过【request】可以获取任何值

  1. package com.item.handler;
  2.  
  3. import org.springframework.web.servlet.HandlerInterceptor;
  4. import org.springframework.web.servlet.ModelAndView;
  5.  
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8. import java.util.Date;
  9.  
  10. /**
  11.  * 自定义拦截器类
  12.  */
  13. public class MyInterceptor implements HandlerInterceptor {// 实现HandlerInterceptor接口
  14. 	/**
  15. 	 * （1） preHandle方法是进行处理器拦截用的，顾名思义，该方法将在Controller处理之前进行调用。
  16. 	 */
  17. 	@Override
  18. 	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
  19. 			throws Exception {
  20. 		System.out.println(new Date() + "--preHandle:" + request.getRequestURL());
  21. 		StringBuffer url = request.getRequestURL();
  22. 		if(url.substring(url.lastIndexOf("/")+1,url.length()).equals("GetName")){
  23. 			System.out.println("------模糊查询方法------");
  24. 			String nickName = request.getParameter("nickName");
  25. 			System.out.println("获取的是nickName："+nickName+"，我可以根据获取的值判断是否是sql注入等操作");
  26. 		}
  27. 		return true;
  28. 	}
  29.  
  30. 	/**
  31. 	 * 这个方法只会在当前这个Interceptor的preHandle方法返回值为true的时候才会执行。
  32. 	 */
  33. 	@Override
  34. 	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
  35. 			ModelAndView modelAndView) throws Exception {
  36. 		System.out.println(new Date() + "--postHandle:" + request.getRequestURL());
  37. 	}
  38.  
  39. 	/**
  40. 	 * 该方法将在postHandle请求完成之后，也就是DispatcherServlet渲染了视图执行
  41. 	 */
  42. 	@Override
  43. 	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
  44. 			throws Exception {
  45. 		System.out.println(new Date() + "--afterCompletion:" + request.getRequestURL());
  46. 	}
  47. }

在上面的实例中，我们定义了一个拦截器类 MyInterceptor ，通过实现 HandlerInterceptor 接口，该类具备了拦截器的功能。

MyInterceptor 中的方法执行顺序为 preHandle – Controller 方法 – postHandle – afterCompletion ，所以拦截器实际上可以对 Controller 方法执行前后进行拦截监控。

最后还有一个非常重要的注意点， preHandle 需要返回布尔类型的值。 preHandle 返回 true 时，对控制器方法的请求才能到达控制器，继而到达 postHandle 和 afterCompletion 方法；如果 preHandle 返回 false ，后面的方法都不会执行。

2、生效配置【com.item.handler】内创建【WebConfig】

如果想让配置器生效，还需要通过配置类进行相应配置。

  1. package com.item.handler;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  6.  
  7. /**
  8.  * Web配置类
  9.  */
  10. @Configuration
  11. public class WebConfig implements WebMvcConfigurer {
  12. 	/**
  13. 	 * 添加Web项目的拦截器
  14. 	 */
  15. 	@Override
  16. 	public void addInterceptors(InterceptorRegistry registry) {
  17. 		// 对所有访问路径，都通过MyInterceptor类型的拦截器进行拦截
  18. 		registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
  19. 	}
  20. }

3、拦截器效果： 

4、拦截器作用

主要完成请求参数的解析、将页面表单参数赋给值栈中相应属性、执行功能检验、程序异常调试等工作，例如：登录校验、Token验证等。

springboot09、监控

前言

因为公司开发的项目多、为客户部署的项目实例多。工作中我们都会经常遇到，由于某个客户的项目突然无法访问，一堆研发、售后部门的同事火急火燎处理问题的场景。

  • 能够有一个界面，监控所有关注的项目实例运行状态。
  • 对于某个项目实例来说，可以监控该实例的各项运行参数，例如内存占用情况、磁盘使用情况、数据库连接情况。

利用 Spring Boot Admin 实现可视化监控，此时至少需要两个项目实例，一个是监控的管理端，一个是被监控的客户端。

注：会与swagger冲突。这个功能是在上线后使用，所以注意关闭swagger。

目录

前言

1、pom配置

2、启动项配置

3、访问主页

4、客户端pom依赖：

5、修改客户端配置

1、pom配置

  1. <!-- Spring Boot Admin 管理端依赖项 -->
  2. <dependency>
  3.     <groupId>de.codecentric</groupId>
  4.     <artifactId>spring-boot-admin-starter-server</artifactId>
  5.     <version>2.2.3</version>
  6. </dependency>

2、启动项配置

  1. package com.item;
  2.  
  3. import de.codecentric.boot.admin.server.config.EnableAdminServer;
  4. import org.mybatis.spring.annotation.MapperScan;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.springframework.boot.builder.SpringApplicationBuilder;
  8. import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
  9. import org.springframework.scheduling.annotation.EnableScheduling;
  10.  
  11. @MapperScan("com.item.dao")
  12. @SpringBootApplication
  13. @EnableScheduling
  14. @EnableAdminServer
  15. public class Action extends SpringBootServletInitializer {
  16.     @Override
  17.     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
  18.         return application.sources(Action.class);
  19.     }
  20.     public static void main(String[] args) {
  21.         SpringApplication.run(Action.class,args);
  22.     }
  23. }

3、访问主页

根据端口号访问就行【http://127.0.0.1:8088/】

4、客户端pom依赖：

  1. <!-- Spring Boot Admin监控客户端依赖 -->
  2. <dependency>
  3.     <groupId>de.codecentric</groupId>
  4.     <artifactId>spring-boot-admin-starter-client</artifactId>
  5.     <version>2.2.3</version>
  6. </dependency>

5、修改客户端配置

  1. # 修改端口号避免冲突
  2. server.port=8081
  3. # 配置监控管理端地址
  4. spring.boot.admin.client.url=http://127.0.0.1:8088
  5. # 客户端的名称，用于区分不同的客户端
  6. spring.boot.admin.client.instance.name=CLIENT1
  7. # 配置客户端展示哪些信息，*表示展示全部信息
  8. management.endpoints.web.exposure.include=*

启动client_test，可以看到应用是1了，可以多启动几个，都能看到

点击进去:

多弄几个效果还是很明显的。

 springboot10、AOP

前言

Spring 最重要的两个功能，就是依赖注入和面向切面编程（AOP）。

AOP 为我们提供了处理问题的全局化视角，使用得当可以极大提高编程效率。

Spring Boot 中使用 AOP 与 Spring 中使用 AOP 几乎没有什么区别，只是建议尽量使用 Java 配置代替 XML 配置。

目录

​编辑springboot09、AOP

前言

1、pom依赖

2、AOP控制器【com.item.aop】

3、测试apo效果

4、使用 AOP 监控性能

1、pom依赖

  1. <!-- AOP -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-aop</artifactId>
  5. </dependency>

2、AOP控制器【com.item.aop】

  1. package com.item.aop;
  2.  
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.Aspect;
  5. import org.aspectj.lang.annotation.Before;
  6. import org.aspectj.lang.annotation.Pointcut;
  7. import org.springframework.stereotype.Component;
  8.  
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11.  
  12. import java.util.Date;
  13.  
  14. /**
  15.  * 日志切面
  16.  */
  17. @Component
  18. @Aspect // 标注为切面
  19. public class LogAspect {
  20. 	private Logger logger = LoggerFactory.getLogger(this.getClass());
  21.  
  22. 	// 切入点表达式，表示切入点为控制器包中的所有方法
  23. 	@Pointcut("within(com.item.controller..*)")
  24. 	public void LogAspect() {
  25. 	}
  26.  
  27. 	// 切入点之前执行
  28. 	@Before("LogAspect()")
  29. 	public void doBefore(JoinPoint joinPoint) {
  30. 		logger.info("访问时间：{}--访问接口:{}", new Date(), joinPoint.getSignature());
  31. 	}
  32. }

3、测试apo效果

可以根据返回的路径进行接口控制

4、使用 AOP 监控性能

在研发项目的性能测试阶段，或者项目部署后，我们会希望查看服务层方法执行的时间。以便精准的了解项目中哪些服务方法执行速度慢，后续可以针对性的进行性能优化。

此时我们就可以使用 AOP 的环绕通知，监控服务方法的执行时间。

  1. package com.item.aop;
  2.  
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Pointcut;
  7. import org.springframework.stereotype.Component;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10. /**
  11.  * 服务层方法切面
  12.  */
  13. @Component
  14. @Aspect // 标注为切面
  15. public class ServiceAspect {
  16. 	private Logger logger = LoggerFactory.getLogger(this.getClass());
  17.  
  18. 	// 切入点表达式，表示切入点为服务层包中的所有方法
  19. 	@Pointcut("within(com.item.controller..*)")
  20. 	public void ServiceAspect() {
  21. 	}
  22.  
  23. 	@Around("ServiceAspect()") // 环绕通知
  24. 	public Object deAround(ProceedingJoinPoint joinPoint) throws Throwable {
  25. 		long startTime = System.currentTimeMillis();// 记录开始时间
  26. 		Object result = joinPoint.proceed();
  27. 		logger.info("接口层方法:{}--执行时间:{}毫秒", joinPoint.getSignature(), System.currentTimeMillis() - startTime);
  28. 		return result;
  29. 	}
  30. }

springboot11、redis

前言

redis可以说是现在最火的非关系型数据库，主要是它处理数据的能力是真的很强。就说win环境的处理能力一般的机器也能在每秒3万次以上，已经很厉害了。我们一般的几万用户的APP根本不需要集群，一个Redis即可搞定几乎所有的小规模并发性问题了。

资源地址：redis服务(windows版)&amp;redis可视化工具.rar_asp.netcoreredis-.Net文档类资源-CSDN下载

目录

1、pom依赖

2、配置声明(application.properties中)

3、编写配置文件【com.item.redis】

4、操作提示

5、RedisBase编码(只包含字符串处理)

6、创建测试接口【com.item.controller】内

7、编写redis层级【com.item.Base】

8、启动测试http://127.0.0.1:8088/swagger-ui.htm

1、pom依赖

  1. <!-- Redis 依赖 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-data-redis</artifactId>
  5. </dependency>
  6. <dependency>
  7.     <groupId>redis.clients</groupId>
  8.     <artifactId>jedis</artifactId>
  9.     <version>3.1.0</version>
  10. </dependency>

2、配置声明(application.properties中)

  1. #---------------------------------
  2. # Redis数据库索引（默认为0）
  3. spring.redis.database=0 
  4. # Redis服务器地址
  5. spring.redis.host=localhost
  6. # Redis服务器连接端口
  7. spring.redis.port=6379 
  8. # Redis服务器连接密码（默认为空）
  9. spring.redis.password=
  10. #连接池最大连接数（使用负值表示没有限制）
  11. spring.redis.pool.max-active=8 
  12. # 连接池最大阻塞等待时间（使用负值表示没有限制）
  13. spring.redis.pool.max-wait=-1 
  14. # 连接池中的最大空闲连接
  15. spring.redis.pool.max-idle=8 
  16. # 连接池中的最小空闲连接
  17. spring.redis.pool.min-idle=0 
  18. # 连接超时时间（毫秒）
  19. spring.redis.timeout=0
  20. #---------------------------------

3、编写配置文件【com.item.redis】

中间有输出语句就是为了表现配置成功，可以删掉。

  1. package com.item.redis;
  2.  
  3. import org.springframework.boot.context.properties.ConfigurationProperties;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.serializer.StringRedisSerializer;
  9. import redis.clients.jedis.JedisPoolConfig;
  10.  
  11. /**
  12.  * 完成对Redis整合的配置
  13.  */
  14. @Configuration
  15. public class RedisConfig {
  16.     /**
  17.      * 1.创建 JedisPoolConfig 对象。在该对象中完成一些链接池配置
  18.      */
  19.     @Bean
  20.     @ConfigurationProperties(prefix = "spring.redis.jedis.pool")
  21.     public JedisPoolConfig JedisPoolConfig() {
  22.         JedisPoolConfig config = new JedisPoolConfig();
  23.         System.out.println("redis默认值：" + config.getMaxIdle());
  24.         System.out.println("redis默认值：" + config.getMinIdle());
  25.         System.out.println("redis默认值：" + config.getMaxTotal());
  26.         return config;
  27.     }
  28.  
  29.     /**
  30.      * 2.创建 JedisConnectionFactory 对象，配置Redis连接属性
  31.      *
  32.      * @param config
  33.      * @return
  34.      */
  35.     @Bean
  36.     @ConfigurationProperties(prefix = "spring.redis")
  37.     public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig config) {
  38.         System.out.println("redis配置完毕：" + config.getMaxIdle());
  39.         System.out.println("redis配置完毕：" + config.getMinIdle());
  40.         System.out.println("redis配置完毕：" + config.getMaxTotal());
  41.         JedisConnectionFactory factory = new JedisConnectionFactory();
  42.         factory.setPoolConfig(config);//关联连接池的配置对象
  43.         return factory;
  44.     }
  45.  
  46.     /**
  47.      * 3.创建RedisTemplate，用于执行Redis操作的方法
  48.      *
  49.      * @param factory
  50.      * @return
  51.      */
  52.     @Bean
  53.     public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
  54.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  55.         //关联JedisConnectionFactory
  56.         template.setConnectionFactory(factory);
  57.         //为key序列化器
  58.         template.setKeySerializer(new StringRedisSerializer());
  59.         //为value设置序列化器
  60.         template.setValueSerializer(new StringRedisSerializer());
  61.  
  62.         return template;
  63.     }
  64.  
  65. }

4、操作提示

  1. //通过依赖注入使用redis
  2. @Autowired
  3. private RedisTemplate redisTemplate;
  4.  
  5. redisTemplate.opsForValue();//操作字符串
  6. redisTemplate.opsForHash();//操作hash 
  7. redisTemplate.opsForList();//操作list
  8. redisTemplate.opsForSet();//操作set
  9. redisTemplate.opsForZSet();//操作有序set

5、RedisBase编码(只包含字符串处理)

  1. package com.item.redis;
  2.  
  3. import com.item.Base.RedisUrl;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.RedisTemplate;
  6. import org.springframework.data.redis.core.StringRedisTemplate;
  7.  
  8.  
  9. public class RedisBase {
  10.     /**
  11.      * 返回的是Object
  12.      */
  13.     @Autowired
  14.     private RedisTemplate redisTemplate;
  15.     /**
  16.      * 返回String
  17.      */
  18.     @Autowired
  19.     private StringRedisTemplate stringRedisTemplate;
  20.     /**
  21.      * 添加值
  22.      * @param key
  23.      * @param value
  24.      * @return
  25.      */
  26.     public boolean redisSet(String key,String value){
  27.         key= RedisUrl.url+key;
  28.         stringRedisTemplate.opsForValue().set(key,value);
  29.         String o = stringRedisTemplate.opsForValue().get(key);
  30.         return o==null?false:true;
  31.     }
  32.  
  33.     /**
  34.      * 存储带倒计时的字符串
  35.      * @param key
  36.      * @param value
  37.      * @param second
  38.      * @return
  39.      */
  40.     public boolean redisSetTime(String key,String value,long second){
  41.         key= RedisUrl.url+key;
  42.         stringRedisTemplate.opsForValue().set(key,value,second);
  43.         String s = stringRedisTemplate.opsForValue().get(key);
  44.         return s==null?false:true;
  45.     }
  46.  
  47.     /**
  48.      * 获取key的value
  49.      * @param key
  50.      * @return
  51.      */
  52.     public String redisGet(String key){
  53.         key= RedisUrl.url+key;
  54.         return stringRedisTemplate.opsForValue().get(key);
  55.     }
  56.  
  57.  
  58.  
  59. }

6、创建测试接口【com.item.controller】内

  1. package com.item.controller;
  2.  
  3.  
  4. import com.item.model.Users;
  5. import com.item.redis.RedisBase;
  6. import com.item.res.SUCCESS;
  7. import io.swagger.annotations.Api;
  8. import io.swagger.annotations.ApiImplicitParam;
  9. import io.swagger.annotations.ApiImplicitParams;
  10. import io.swagger.annotations.ApiOperation;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  14. import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
  15. import org.springframework.web.bind.annotation.CrossOrigin;
  16. import org.springframework.web.bind.annotation.GetMapping;
  17. import org.springframework.web.bind.annotation.RequestMapping;
  18. import org.springframework.web.bind.annotation.RestController;
  19.  
  20. @Api("用户操作接口")
  21. @RestController
  22. @CrossOrigin
  23. @RequestMapping("Redis/")
  24. public class RedisController extends RedisBase {
  25.     /**
  26.      * 测试Redis添加
  27.      */
  28.     @GetMapping("SetRedis")
  29.     @ApiOperation(value = "添加key_value",notes = "没啥留言的")
  30.     @ApiImplicitParams({
  31.             @ApiImplicitParam(name = "key",required = true,paramType = "query",dataType = "String",value = "redis_key"),
  32.             @ApiImplicitParam(name = "value",required = true,paramType = "query",dataType = "String",value = "redis_value")
  33.     })
  34.     public Object testRedisSet(String key,String value){
  35.         redisSet(key,value);
  36.         return new SUCCESS("写入成功");
  37.     }
  38.  
  39.     /**
  40.      * 测试Redis查询
  41.      */
  42.     @GetMapping("GetRedis")
  43.     @ApiOperation(value = "获取key信息",notes = "没啥留言的")
  44.     @ApiImplicitParams({
  45.             @ApiImplicitParam(name = "key",required = true,paramType = "query",dataType = "String",value = "redis_key")
  46.     })
  47.     public Object testRedisGet(String key){
  48.         return new SUCCESS(redisGet(key));
  49.     }
  50.  
  51. }

7、编写redis层级【com.item.Base】

  1. package com.item.Base;
  2.  
  3. public class RedisUrl {
  4.     public static final String url="demo:infos:";
  5. }

8、启动测试http://127.0.0.1:8088/swagger-ui.htm

能写入，能查询，没问题。 

我个人喜欢用String和list，自己用自己封装吧。

https://blog.csdn.net/feng8403000/article/details/125354540
posted on 2022-08-29 19:15  sunny123456  阅读(75)  评论(0)  编辑  收藏  举报