使用IDEA快速搭建Springboot项目（Springboot+JPA）（统一异常处理+HTTP请求日志处理）

喜欢ヅ旅行 2022-05-11 11:34 371阅读 0赞

1.使用IDEA新建一个项目，选择左侧的spring Initializr,选择好jdk版本之后点击下一步

![70][]

2.然后idea会自动创建一个maven项目。之后点击下一步

![70 1][]

3.选择项目所需要的依赖，如web,jpa,mysql等等

![70 2][]

4.最后一步：给项目命名，选择项目地址，就创建完成了。

# 项目的启动入口 #

![70 3][]

springboot项目创建完成会自动创建一个项目入口，直接运行就可以了，当然，项目中什么都没有访问的话会报404错误。

# 使用JPA完成对数据库的CRUD #

1.首先将项目默认的application.properties文件改为：application.yml文件（官方推荐）

![70 4][]

jpa的配置：ddl-auto:create会是项目自动在数据库中创建对应的表

2.首先创建一个pojo包，并创建一个javabean。

package com.tellhow.demo.pojo;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    import javax.persistence.*;
    import javax.validation.constraints.Min;
    
    @Component//加入spring容器中
    @Entity     //映射数据库中的表
    @ConfigurationProperties(prefix = "user")//配置属性bean,会将yml文件中的前缀为user的属性值映射到此bean中用来直接使用
    public class User {
        @Id
        @GeneratedValue
        private Integer id;
    
        public User() {
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        private String username;
    
        @Min(value =12,message = "年龄不能小于12岁")//表单验证
        private int age;
    
        private String cupSize;
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getCupSize() {
            return cupSize;
        }
    
        public void setCupSize(String cupSize) {
            this.cupSize = cupSize;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "username='" + username + '\'' +
                    ", age=" + age +
                    ", cupSize='" + cupSize + '\'' +
                    '}';
        }
    }

此时启动项目，springboot就能根据yml里的配置，和javabean上的@Entity注解，在数据库中创建一张对应的表。

3.编写repository接口，（即平常的Dao接口），继承JPA的JPARepository接口。（里面封装了一些对数据库的基本操作，类似于mybatis的通用mapper）

package com.tellhow.demo.repository;
    
    import com.tellhow.demo.pojo.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    
    public interface UserRepository extends JpaRepository<User,Integer>{
    
    }

4.编写控制层（增删改查rest接口）。

package com.tellhow.demo.controller;
    
    import com.tellhow.demo.pojo.User;
    import com.tellhow.demo.repository.UserRepository;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.validation.BindingResult;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.Valid;
    import java.util.List;
    
    @RestController
    @RequestMapping("/say")
    public class UserController {
        private static Logger logger= LoggerFactory.getLogger(UserController.class);
        @Autowired
        private UserRepository userRepository;
    
        @Autowired
        private User user;
    
        @RequestMapping(value = "/hello",method = RequestMethod.GET)
        public Object sayHello(){
            return user;
        }
    
        /**
         * 查询所有
         * @return
         */
        @GetMapping("/users")
        public List<User> getUsers(){
            return userRepository.findAll();
        }
    
        /**
         * 新增
         * @param user
         * @return
         */
        @PostMapping("/user")
        public Object saveUser(@Valid User user, BindingResult result){
            if (result.hasErrors()){
                logger.info(result.getFieldError().getField(),result.getFieldError().getDefaultMessage());
                return result.getFieldError().getDefaultMessage();
            }
            return userRepository.save(user);
        }
    
        /**
         * 修改
         * @param user
         * @return
         */
        @PutMapping("/user")
        public User updateUser(User user){
            return userRepository.save(user);
        }
    
        /**
         * 删除
         * @param user
         */
        @DeleteMapping("/user")
        public void deleteUser(User user){
            userRepository.delete(user);
        }
    }

# 项目统一异常处理 #

新建一个ExceptionHandle,使用@ControllerAdvice注解标识。

@ControllerAdvie是spring3.2之后出现的，常用来配合@ExceptionHandle做异常处理

package com.tellhow.demo.exception;
    
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    /**
     * 统一异常处理
     *
     */
    @ControllerAdvice//控制器增强，
                    // 配合@ExceptionHandler使用，
                    // 如果不用@ControllerAdvice,
                    // 则ExceptionHandler只能在当前出异常的controller里使用，
                    // 使用controllerAdvice则可以接触这个限制，
    public class ExceptionHandle {
    
        /**
         * 此方法会对项目抛出的异常统一捕获，然后将异常信息返回给客户端
         * @param e
         * @return
         */
        @ExceptionHandler//@ExceptionHandler(Exception.class) 括号里可以可以指定异常类，也可以不指定，可以自动映射
        @ResponseBody
        public Object handle(Exception e){
    
            //对各种异常进行判断处理。
            if(e instanceof NullPointerException){
                //处理
            }
    
            //···
    
    
            return e.getMessage();
        }
    }

这样项目发生异常都会被handle方法捕获并处理返回给客户端。

# AOP处理HTTP请求日志 #

新建一个HttpAspect类，用@component+@Aspect注解标识。代表此类是一个切面。

package com.tellhow.demo.aspect;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    
    
    @Aspect
    @Component
    public class HttpAspect {
        private static Logger logger= LoggerFactory.getLogger(HttpAspect.class);
    
        /**
         * 此方法用来做表达式的，切入点表达式，即要增强哪些方法。
         */
        @Pointcut("execution(public * com.tellhow.demo.controller.UserController.getUsers())")
        public void log(){//
        }
    
        @Before("log()")
        public void logBefore(){
            logger.info("before........................");
        }
    
        @After("log()")
        public void logAfter(){
            logger.info("after***************************");
        }
    
        @After("log()")
        public void logDetailAfter(JoinPoint point){
            ServletRequestAttributes attributes=(ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request =attributes.getRequest();
            //请求url
            logger.info("url={}",request.getRequestURI());
            //请求方法
            logger.info("method={}",request.getMethod());
            //请求ip
            logger.info("ip={}",request.getRemoteAddr());
            //类方法
            logger.info("class_method={}",point.getSignature().getDeclaringType()+"."+point.getSignature().getName());
            //参数
            logger.info("args={}",point.getArgs());
    
        }
    
        @AfterReturning(returning = "object",pointcut = "log()")//获得被增强方法的返回值。
        public void doAfterReturning(Object object){
            System.out.print(object.toString());
        }
    }

想要对哪些方法记录日志，直接写切点的表达式内即可。

以上即一个完整的springboot项目，东西虽少，五脏俱全。

[70]: /images/20220505/fd22533809444a4f967cfc2e791cf416.png
[70 1]: /images/20220505/4729e27b353643b6b7b99e50ac8e678d.png
[70 2]: /images/20220505/20106445711f464aa19a19c9ed2a0fa1.png
[70 3]: /images/20220505/50320f521c21424490dce62304a362cc.png
[70 4]: /images/20220505/7f076037700b4662a91cb844f936bffc.png