可以用springboot+mybatis-plus编写后端代码用户登录注册以及用户车位信息的增删改查(使用JWT+token以及拦截器和异常处理)的完整后端代码吗(不用给我依赖xml文件

好的，以下是使用Spring Boot和Mybatis-Plus编写的用户登录注册和车位信息增删改查的完整后端代码，同时使用了JWT+token、拦截器和异常处理。

首先是pom.xml文件：

<dependencies>
    <!-- Spring Boot -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Mybatis-Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.0</version>
    </dependency>

    <!-- JWT -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>

    <!-- MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

接下来是application.properties文件：

# 数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

# Mybatis-Plus 配置
mybatis-plus.mapper-locations=classpath*:mapper/*.xml
mybatis-plus.type-aliases-package=com.example.demo.model

# JWT 配置
jwt.secret=YourSecretKey
jwt.expire-time=3600000

其中，jwt.secret为JWT的密钥，jwt.expire-time为JWT的过期时间，单位为毫秒。

接下来是实体类User.java：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String username;
    private String password;
}

实体类ParkingLot.java：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ParkingLot {
    private Long id;
    private String name;
    private Integer capacity;
    private Integer vacant;
}

接下来是Mapper接口UserMapper.java：

@Mapper
public interface UserMapper extends BaseMapper<User> {
    User selectByUsername(String username);
}

Mapper接口ParkingLotMapper.java：

@Mapper
public interface ParkingLotMapper extends BaseMapper<ParkingLot> {
}

接下来是Controller类UserController.java：

@RestController
@RequestMapping("/api/user")
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody User user) {
        User dbUser = userMapper.selectByUsername(user.getUsername());
        if (dbUser == null || !dbUser.getPassword().equals(user.getPassword())) {
            throw new UnauthorizedException("用户名或密码错误");
        }
        String token = JwtUtils.generateToken(dbUser.getId(), dbUser.getUsername());
        Map<String, Object> map = new HashMap<>();
        map.put("token", token);
        return ResponseEntity.ok(map);
    }

    @PostMapping("/register")
    public ResponseEntity<?> register(@RequestBody User user) {
        User dbUser = userMapper.selectByUsername(user.getUsername());
        if (dbUser != null) {
            throw new BadRequestException("用户名已存在");
        }
        userMapper.insert(user);
        return ResponseEntity.ok("注册成功");
    }
}

Controller类ParkingLotController.java：

@RestController
@RequestMapping("/api/parkinglot")
public class ParkingLotController {
    @Autowired
    private ParkingLotMapper parkingLotMapper;

    @GetMapping("")
    public ResponseEntity<?> getAll() {
        List<ParkingLot> parkingLots = parkingLotMapper.selectList(null);
        return ResponseEntity.ok(parkingLots);
    }

    @PostMapping("")
    public ResponseEntity<?> add(@RequestBody ParkingLot parkingLot) {
        parkingLotMapper.insert(parkingLot);
        return ResponseEntity.ok("添加成功");
    }

    @PostMapping("/{id}")
    public ResponseEntity<?> update(@PathVariable Long id, @RequestBody ParkingLot parkingLot) {
        ParkingLot dbParkingLot = parkingLotMapper.selectById(id);
        if (dbParkingLot == null) {
            throw new NotFoundException("车位不存在");
        }
        parkingLot.setId(id);
        parkingLotMapper.updateById(parkingLot);
        return ResponseEntity.ok("修改成功");
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> delete(@PathVariable Long id) {
        parkingLotMapper.deleteById(id);
        return ResponseEntity.ok("删除成功");
    }
}

接下来是JwtUtils.java工具类：

public class JwtUtils {
    private static final String SECRET_KEY = "YourSecretKey";
    private static final long EXPIRE_TIME = 3600000;

    public static String generateToken(Long id, String username) {
        Date now = new Date();
        Date expireTime = new Date(now.getTime() + EXPIRE_TIME);
        return Jwts.builder()
                .setId(id.toString())
                .setSubject(username)
                .setIssuedAt(now)
                .setExpiration(expireTime)
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    public static Claims parseToken(String token) {
        try {
            return Jwts.parser()
                    .setSigningKey(SECRET_KEY)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (JwtException e) {
            throw new UnauthorizedException("无效的token");
        }
    }
}

接下来是TokenInterceptor.java拦截器：

public class TokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String authorization = request.getHeader("Authorization");
        if (authorization == null || !authorization.startsWith("Bearer ")) {
            throw new UnauthorizedException("未授权访问");
        }
        String token = authorization.substring(7);
        JwtUtils.parseToken(token);
        return true;
    }
}

最后是异常处理类GlobalExceptionHandler.java：

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(BadRequestException.class)
    public ResponseEntity<?> handleBadRequestException(BadRequestException e) {
        return ResponseEntity.badRequest().body(e.getMessage());
    }

    @ExceptionHandler(NotFoundException.class)
    public ResponseEntity<?> handleNotFoundException(NotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getMessage());
    }

    @ExceptionHandler(UnauthorizedException.class)
    public ResponseEntity<?> handleUnauthorizedException(UnauthorizedException e) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(e.getMessage());
    }
}

至此，完整的后端代码就完成了。