• 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
  • 相关阅读:
    elasticsearch为什么比mysql快
    elasticsearch（lucene）索引数据过程
    UidGenerator springboot2集成篇
    StampedLock的理解和使用
    EsClientRHL-elasticsearch java客户端开源工具
    Spring只定义接口自动代理接口实现类
    浅谈浏览器存储（cookie、localStorage、sessionStorage）
    图片无缝拼接
    js中变量的连续赋值
    web页面ios浏览器img图片的坑
  • 原文地址：https://www.cnblogs.com/sunny3158/p/16637076.html
Copyright © 2020-2023  润新知