springboot初始化项目

1.idea创建springBoot项目

2.pom文件引入依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <java.version>8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.7.0</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.dqgy.dqgybase.DqgyBaseApplication</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>

3.返回结果类型枚举

新建ResultEnum calss

public enum ResultEnum {
    SUCCESS(200,"操作成功"),
    FAIL(400,"操作失败");

    private final String msg;
    private final int code;

    ResultEnum(int code,String msg) {
        this.msg = msg;
        this.code = code;
    }

    public String getMsg() {
        return this.msg;
    }

    public int getCode() {
        return this.code;
    }

}

四返回结果定义

新建Result class

import com.boot.base.config.ResultEnum;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
public class Result<T> {

    protected boolean success;
    protected int code;
    protected String msg;
    protected T data;

    public Result(boolean success, String msg, int code) {
        this.success = success;
        this.msg = msg;
        this.code = code;
    }

    public Result(boolean success, String msg, int code, T data) {
        this.success = success;
        this.msg = msg;
        this.code = code;
        this.data = data;
    }

    public static <T> Result<T> success(T data) {
        return new Result<>(true, ResultEnum.SUCCESS.getMsg(), ResultEnum.SUCCESS.getCode(), data);
    }

    public static <T> Result<T> success() {
        return new Result<>(true, ResultEnum.SUCCESS.getMsg(), ResultEnum.SUCCESS.getCode());
    }

    public static <T> Result<T> fail() {
        return new Result<>(false, ResultEnum.FAIL.getMsg(), ResultEnum.FAIL.getCode());
    }

    public static <T> Result<T> fail(String msg) {
        return new Result<>(false, msg, ResultEnum.FAIL.getCode());
    }

    public static <T> Result<T> fail(ResultEnum resultEnum) {
        return fail(resultEnum.getMsg(), resultEnum.getCode());
    }

    public static <T> Result<T> fail(String msg, int code) {
        return new Result<>(false, msg, code);
    }

    public static <T> Result<T> status(boolean flag, T data) {
        return flag ? success(data) : fail();
    }

    public static <T> Result<T> status(boolean flag) {
        return flag ? success() : fail();
    }
}

自定义获取spirngbootContext上下文工具类

import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.BeansException;
import org.springframework.boot.env.OriginTrackedMapPropertySource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

@Component
public class SpringContextUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextUtil.applicationContext = applicationContext;
    }

    /**
     * 获取上下文
     * @return
     */
    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }

    /**
     * 获取springContext上下文容器中所有bean名称
     * @return
     */
    public static String[] getBeanDefinitionNames(){
        return applicationContext.getBeanDefinitionNames();
    }

    /**
     * 根据class获取bean名称
     * @param tClass
     * @param <T>
     * @return
     */
    public static <T> T getBeanName(Class<T> tClass){
        return applicationContext.getBean(tClass);
    }

    /**
     * 根据bean名称获取类型
     * @param beanName bean名称
     * @return
     */
    public static Class<?> getType(String beanName){
        return applicationContext.getType(beanName);
    }

    /**
     * 根据property名称获取配置信息
     * @param propertyName
     * @return
     */
    public static Object getProperty(String propertyName){
       ConfigurableEnvironment environment = (ConfigurableEnvironment) applicationContext.getEnvironment();
       return environment.getProperty(propertyName);
    }
    public static List<String> getProperList(String propertyPrefix){
        AtomicReference<List<String>> reference = new AtomicReference<>();
        ConfigurableEnvironment environment = (ConfigurableEnvironment) applicationContext.getEnvironment();
        environment.getPropertySources().stream().forEach(propertySource -> {
            if (propertySource instanceof OriginTrackedMapPropertySource){
                List<String> props = Arrays.asList(((OriginTrackedMapPropertySource) propertySource).getPropertyNames());
                reference.set(props.stream().filter(e -> e.startsWith(propertyPrefix)).collect(Collectors.toList()));
            }
        });
        return reference.get();
    }

    /**
     * 判断某个配置是否存在
     * @param propertyName 配置名称
     * @param notBlank 不能为空字符或null
     * @return
     */
    public static boolean containProperty(String propertyName, boolean notBlank){
        Object property = applicationContext.getEnvironment().getProperty(propertyName);
        if (property == null){
            return false;
        }else if(notBlank && Strings.isBlank(property.toString())){
            return false;
        }
        return true;
    }
}

全局异常捕捉GlobalException类

import com.boot.base.excetion.CustomException;
import com.boot.base.common.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@Slf4j
@RestControllerAdvice
public class GlobalException {

    @ExceptionHandler(CustomException.class)
    public Result<String> error(CustomException e){
        log.error(e.getMessage());
        return Result.fail(e.getMessage());
    }
}

自定义异常 CustomException 类

import com.boot.base.common.Result;
import com.boot.base.config.ResultEnum;

public class CustomException extends RuntimeException{

    private final Result<?> result;

    public Result<?> getResult(){
        return this.result;
    }

    public CustomException(String msg){
        super(msg);
        this.result = Result.fail(ResultEnum.FAIL);
        this.result.setMsg(msg);
    }
}

时间格式化常量

public class FormatConstant {
    public static final String DATE_SDF10 = "yyyy-MM-dd";
    public static final String DATE_SDF16 = "yyyy-MM-dd HH:mm:ss";
}

创建entity类

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.time.LocalDateTime;

import com.boot.base.config.FormatConstant;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

/**
 * 
 * @TableName sys_user
 */
@TableName(value ="sys_user")
@Data
public class User {
    /**
     * 主键id
     */
    @TableId(value = "id")
    private Long id;

    /**
     * 名称
     */
    @TableField(value = "name")
    private String name;

    /**
     * 密码
     */
    @TableField(value = "password")
    private String password;

    /**
     * 创建时间
     */
    @TableField(value = "create_time")
    @JsonFormat(pattern = FormatConstant.DATE_SDF16)
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    @TableField(value = "update_time")
    @JsonFormat(pattern = FormatConstant.DATE_SDF16)
    private LocalDateTime updateTime;

    /**
     * 手机号码
     */
    @TableField(value = "phone")
    private String phone;

    /**
     * 登录类型
     */
    @TableField(value = "login_type")
    private String loginType;

    @TableField(exist = false)
    private static final long serialVersionUID = 1L;
}

创建mapper interface

import com.boot.base.po.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
* @author pc
* @description 针对表【sys_user】的数据库操作Mapper
* @createDate 2022-12-08 13:25:22
* @Entity com.dqgy.dqgybase.po.User
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {

}

创建service interface 和实现类

import com.boot.base.po.User;
import com.baomidou.mybatisplus.extension.service.IService;

/**
* @author pc
* @description 针对表【sys_user】的数据库操作Service
* @createDate 2022-12-08 13:25:22
*/
public interface UserService extends IService<User> {

}

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.boot.base.po.User;
import com.boot.base.service.UserService;
import com.boot.base.mapper.UserMapper;
import org.springframework.stereotype.Service;

/**
* @author pc
* @description 针对表【sys_user】的数据库操作Service实现
* @createDate 2022-12-08 13:25:22
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService{

}

创建controller

import com.boot.base.common.Result;
import com.boot.base.po.User;
import com.boot.base.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

@Slf4j
@RestController
@RequestMapping("/base")
public class UserController {
    @Resource
    private UserService userService;

    @GetMapping("/dtoList")
    public Result<List<User>> dtoList() {
        List<User> list = userService.list();
        return Result.success(list);
    }

    @GetMapping("/{id}")
    public Result<User> detail(@PathVariable("id") Long id) {
        User user = userService.getById(id);
        return Result.success(user);
    }
}

五、测试接口