Spring总结

项目结构

在Spring和Spring Boot项目中，项目结构通常遵循一定的分层设计原则，以保持代码的清晰和可维护性。常见的项目结构如下：


src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           ├── controller  // 控制层，处理HTTP请求
│   │           ├── service     // 服务层，处理业务逻辑
│   │           ├── mapper      // MyBatis Mapper接口
│   │           ├── entity      // 实体类，对应数据库表
│   │           ├── config      // 配置类，如Spring配置、MyBatis配置等
│   │           ├── interceptor // 拦截器
│   │           ├── filter      // 过滤器
│   │           └── Application.java // 程序入口
│   └── resources
│       ├── application.yml     // 配置文件
│       ├── mapper              // MyBatis XML映射文件
│       └── static              // 静态资源
└── test
    └── java
        └── com
            └── example
                └── test         // 测试类

配置文件

Spring Boot使用application.yml或application.properties作为主要的配置文件。常见的配置项包括：

服务器配置：如端口号、上下文路径等。
数据库配置：如数据库URL、用户名、密码等。
日志配置：如日志级别、日志文件路径等。
缓存配置：如Redis配置。

示例：

yaml
server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

logging:
  level:
    com.example: DEBUG

程序入口

Spring Boot项目的入口通常是一个带有@SpringBootApplication注解的类，该类会启动Spring Boot应用。

java
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

路由

在Spring Boot中，路由通常由控制器（Controller）类来处理。使用@RequestMapping、@GetMapping、@PostMapping等注解来定义路由。

java
package com.example.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/users")
    public String getUsers() {
        return "List of users";
    }
}

传参

Spring Boot支持多种传参方式：

路径参数：使用@PathVariable注解。
查询参数：使用@RequestParam注解。
请求体参数：使用@RequestBody注解。

示例：

java
@GetMapping("/users/{id}")
public String getUserById(@PathVariable Long id) {
    return "User ID: " + id;
}

@GetMapping("/users")
public String getUsers(@RequestParam String name) {
    return "User name: " + name;
}

@PostMapping("/users")
public String createUser(@RequestBody User user) {
    return "Created user: " + user.getName();
}

拦截器

拦截器（Interceptor）用于在请求处理前后执行一些操作，如权限验证、日志记录等。通过实现HandlerInterceptor接口来创建拦截器。

java
package com.example.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 请求处理前的逻辑
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 请求处理后的逻辑
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 请求完成后的逻辑
    }
}

在配置类中注册拦截器：

java
package com.example.config;

import com.example.interceptor.MyInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/api/**");
    }
}

过滤器

过滤器（Filter）用于在请求到达Servlet之前或之后执行一些操作。通过实现Filter接口来创建过滤器。

java
package com.example.filter;

import javax.servlet.*;
import java.io.IOException;

public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 请求处理前的逻辑
        chain.doFilter(request, response);
        // 请求处理后的逻辑
    }
}

在配置类中注册过滤器：

java
package com.example.config;

import com.example.filter.MyFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<MyFilter> myFilter() {
        FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new MyFilter());
        registrationBean.addUrlPatterns("/api/*");
        return registrationBean;
    }
}

数据库操作

基本增删查改

MyBatis-Plus提供了非常便捷的CRUD操作，通过继承BaseMapper接口即可实现。

java
package com.example.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

在Service层中使用：

java
package com.example.service;

import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    public void createUser(User user) {
        userMapper.insert(user);
    }

    public void updateUser(User user) {
        userMapper.updateById(user);
    }

    public void deleteUser(Long id) {
        userMapper.deleteById(id);
    }
}

条件查询

MyBatis-Plus提供了强大的条件构造器QueryWrapper，用于构建复杂的查询条件。

java
package com.example.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public List<User> getUsersByName(String name) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name);
        return userMapper.selectList(queryWrapper);
    }
}

事务

Spring提供了声明式事务管理，通过@Transactional注解来实现。

java
package com.example.service;

import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void createUserWithTransaction(User user) {
        userMapper.insert(user);
        // 如果发生异常，事务会回滚
        if (true) {
            throw new RuntimeException("Transaction will rollback");
        }
    }
}

钩子

MyBatis-Plus提供了一些钩子方法，如@TableField注解中的fill属性，用于在插入或更新时自动填充字段。

java
package com.example.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@TableName("user")
public class User {

    @TableId
    private Long id;

    private String name;

    @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
        this.strictInsertFill(metaObject, "updateTime", Date.class, new Date());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }
}

中间件集成

Redis集成

Spring Boot提供了对Redis的集成支持，通过spring-boot-starter-data-redis依赖即可实现。

在application.yml中配置Redis：

yaml
spring:
  redis:
    host: localhost
    port: 6379

使用RedisTemplate进行操作：

java
package com.example.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public void setValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public String getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

通过以上配置和代码示例，你可以快速搭建一个基于Spring Boot和MyBatis-Plus的项目，并集成Redis等中间件。

目录