Spring Boot 从入门到精通（超详细教程）

1. Spring Boot 是什么

Spring 自 2002 年起成为 Java EE 开发的标准，但随着技术发展，其繁琐的 XML 配置和第三方框架整合问题导致开发效率降低。

2012 年，Mike Youngstrom 提出在 Spring 中支持无容器 Web 应用架构，促使 2013 年 Spring Boot 项目启动。目前版本已更新至 2.0.3 RELEASE。

核心特点：

• 并非替代 Spring，而是提升开发者体验的工具
• 集成大量第三方库配置，支持"零配置开箱即用"
• 基于 Java 配置，仅需少量代码即可快速搭建项目
• 让开发者专注于业务逻辑而非配置

2. 为什么学习 Spring Boot

2.1 官方定位

• Spring Boot：Build Anything（构建任何东西），快速启动运行，最小化配置
• Spring Cloud：Coordinate Anything（协调任何事情）
• Spring Cloud Data Flow：Connect Everything（连接任何东西）

2.2 核心优点

1. 良好的基因：基于 Spring 4.0，继承 Spring 优秀特性
2. 简化编码：通过 starter 依赖自动集成相关库
3. 简化配置：采用 Java Config 替代 XML，集中配置在 application.yml
4. 简化部署：内嵌 Tomcat，支持 jar 包一键启动
5. 简化监控：集成 actuator 实现运行状态监控

2.3 发展趋势

微服务架构是未来趋势，Spring Boot 作为微服务开发的基础框架，官方大力推荐，应用前景广泛。

3. 课程内容

• 基础篇（01-10课）：Json 处理、日志、配置、MVC、异常处理等核心功能
• 进阶篇（11-17课）：拦截器、缓存、安全认证、消息队列等组件集成
• 最终目标：掌握实际项目开发能力，提供可直接复用的架构模板

4. 开发环境配置

工具	版本
开发工具	IDEA 2017
JDK	1.8
Spring Boot	2.0.3 RELEASE
Maven	3.5.2

核心插件：FastJson、Swagger2、Thymeleaf、MyBatis、Redis 等

第01课：开发环境搭建和项目启动

1. JDK 配置

1. 打开 File->Project Structure
2. 选择 SDKs，指定 JDK 安装目录
3. 自定义名称（如 1.8）

2. 项目构建

2.1 IDEA 快速构建

• File->New->Project
• 选择 Spring Initializr，配置 Group（如 com.itcodai）、Artifact（如 course01）
• 选择 Web 依赖

2.2 官方构建

• 访问 http://start.spring.io/
• 配置项目信息后下载，导入 IDEA

3. Maven 配置

<!-- 阿里镜像配置 -->
<mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>*</mirrorOf>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

4. 项目结构

src/main/java       # 业务代码
src/main/resources  # 静态资源和配置文件
src/test/java       # 测试代码

5. 启动类

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

6. 测试示例

@RestController
@RequestMapping("/start")
public class StartController {
    @RequestMapping("/springboot")
    public String start() {
        return "Welcome to the world of Spring Boot!";
    }
}

访问 localhost:8080/start/springboot 即可看到结果。

第02课：返回 Json 数据及封装

1. 默认 Json 处理

Spring Boot 默认使用 Jackson 处理 Json，通过 @RestController 自动返回 Json 格式：

@RestController // 包含 @Controller + @ResponseBody
public class JsonController {
    @RequestMapping("/user")
    public User getUser() {
        return new User(1L, "测试", "123456");
    }
}

2. 自定义 null 处理

@Configuration
public class JacksonConfig {
    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        // null 转为空字符串
        mapper.getSerializerProvider().setNullValueSerializer(
            new JsonSerializer<Object>() {
                @Override
                public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
                    jsonGenerator.writeString("");
                }
            }
        );
        return mapper;
    }
}

3. 集成 FastJson

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.35</version>
</dependency>

4. 统一返回结构

public class JsonResult<T> {
    private T data;
    private String code;
    private String msg;

    // 默认构造：操作成功
    public JsonResult(T data) {
        this.data = data;
        this.code = "0";
        this.msg = "操作成功!";
    }
}

第03课：日志记录（SLF4J）

1. 日志级别

从高到低：ERROR > WARN > INFO > DEBUG > TRACE

2. 配置示例（logback.xml）

<configuration>
    <!-- 日志格式 -->
    <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
    <!-- 日志路径 -->
    <property name="FILE_PATH" value="D:/logs/demo.%d{yyyy-MM-dd}.%i.log" />

    <!-- 控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <!-- 文件输出 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${FILE_PATH}</fileNamePattern>
            <maxHistory>15</maxHistory> <!-- 保存15天 -->
        </rollingPolicy>
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <!-- 全局级别 -->
    <root level="INFO">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="FILE" />
    </root>
</configuration>

3. 使用示例

private static final Logger logger = LoggerFactory.getLogger(TestController.class);

logger.info("info 级别日志");
logger.error("error 级别日志");

第04课：属性配置

1. 单一配置

# application.yml
url:
  orderUrl: http://localhost:8002

@Value("${url.orderUrl}")
private String orderUrl;

2. 多配置封装

@Component
@ConfigurationProperties(prefix = "url")
public class MicroServiceUrl {
    private String orderUrl;
    private String userUrl;
    // get/set 略
}

3. 多环境配置

• 开发环境：application-dev.yml
• 生产环境：application-pro.yml

# 激活开发环境
spring:
  profiles:
    active: dev

第05课：MVC 支持

核心注解

注解	作用
@RestController	组合 @Controller + @ResponseBody
@RequestMapping	映射请求路径，支持 GET/POST 等方法
@PathVariable	获取 URL 路径参数
@RequestParam	获取请求参数（QueryString/表单）
@RequestBody	接收 JSON 格式请求体

示例

@RestController
@RequestMapping("/user")
public class UserController {
    // 路径参数
    @GetMapping("/{id}")
    public String getUserById(@PathVariable Long id) { ... }

    // 请求参数
    @GetMapping("/query")
    public String getUserByName(@RequestParam String name) { ... }

    // 接收 JSON
    @PostMapping("/add")
    public String addUser(@RequestBody User user) { ... }
}

第06课：集成 Swagger2

1. 依赖

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.2.2</version>
</dependency>

2. 配置

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.itcodai.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Spring Boot API 文档")
                .version("1.0")
                .build();
    }
}

3. 注解使用

注解	作用
@Api	标识 Controller 类
@ApiOperation	描述方法功能
@ApiParam	描述参数信息
@ApiModel	描述实体类
@ApiModelProperty	描述实体属性

第07课：集成 Thymeleaf

1. 依赖

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

2. 配置

spring:
  thymeleaf:
    cache: false # 开发时关闭缓存

3. 基础用法

<!-- 引入命名空间 -->
<html xmlns:th="http://www.thymeleaf.org">

<!-- 文本替换 -->
<h1 th:text="${title}">默认标题</h1>

<!-- 循环 -->
<ul>
    <li th:each="user : ${users}" th:text="${user.name}"></li>
</ul>

第08课：全局异常处理

1. 统一异常处理类

@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
    // 处理空指针异常
    @ExceptionHandler(NullPointerException.class)
    public JsonResult handleNullPointerException(NullPointerException e) {
        return new JsonResult<>("500", "空指针异常");
    }

    // 处理所有异常
    @ExceptionHandler(Exception.class)
    public JsonResult handleException(Exception e) {
        return new JsonResult<>("500", "系统异常");
    }
}

2. 自定义异常

public enum BusinessMsgEnum {
    PARAM_EXCEPTION("100", "参数异常");

    private String code;
    private String msg;
    // 构造和 getter 略
}

public class BusinessErrorException extends RuntimeException {
    private BusinessMsgEnum msgEnum;
    // 构造略
}

第09课：AOP 处理

1. 依赖

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

2. 核心注解

注解	作用
@Aspect	标识切面类
@Pointcut	定义切入点
@Before	前置通知
@After	后置通知
@AfterReturning	返回后通知
@AfterThrowing	异常通知

3. 示例

@Aspect
@Component
public class LogAspect {
    // 定义切入点：拦截 controller 包下所有方法
    @Pointcut("execution(* com.itcodai.controller..*.*(..))")
    public void pointCut() {}

    @Before("pointCut()")
    public void before(JoinPoint joinPoint) {
        // 打印请求信息
        System.out.println("请求方法：" + joinPoint.getSignature().getName());
    }
}

第10课：集成 MyBatis

1. 依赖

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

2. 配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
mybatis:
  configuration:
    map-underscore-to-camel-case: true # 开启驼峰命名

3. 注解方式

@Mapper
public interface UserMapper {
    @Select("select * from user where id = #{id}")
    User getUserById(Long id);

    @Insert("insert into user(name) values(#{name})")
    int insertUser(User user);
}

第11课：事务管理

1. 核心注解：@Transactional

@Service
public class UserService {
    @Transactional(rollbackFor = Exception.class) // 异常时回滚
    public void updateUser(User user) {
        // 业务逻辑
        userMapper.update(user);
        // 手动抛异常测试回滚
        if (user.getId() == 0) {
            throw new RuntimeException("参数异常");
        }
    }
}

2. 注意事项

• 仅对 public 方法有效
• 默认只回滚 RuntimeException
• 异常被捕获后不会回滚

第12课：监听器

1. 内置监听器

// 监听 Servlet 上下文初始化
@Component
public class MyServletContextListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 初始化缓存数据
    }
}

// 监听 Session
@Component
public class MyHttpSessionListener implements HttpSessionListener {
    private int count = 0;

    @Override
    public void sessionCreated(HttpSessionEvent se) {
        count++; // 在线人数+1
    }
}

2. 自定义事件

// 自定义事件
public class MyEvent extends ApplicationEvent {
    private User user;
    // 构造略
}

// 监听器
@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        // 处理事件
    }
}

// 发布事件
@Service
public class UserService {
    @Autowired
    private ApplicationContext context;

    public void publishEvent() {
        context.publishEvent(new MyEvent(new User()));
    }
}

第13课：拦截器

1. 定义拦截器

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 登录验证
        if (request.getSession().getAttribute("user") == null) {
            response.sendRedirect("/login");
            return false; // 拦截
        }
        return true; // 放行
    }
}

2. 配置拦截器

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**") // 拦截所有
                .excludePathPatterns("/login", "/static/**"); // 放行登录页和静态资源
    }
}

第14课：集成 Redis

1. 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. 配置

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password: 123456
    database: 0

3. 常用操作

@Service
public class RedisService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    // 字符串操作
    public void setString(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    // Hash 操作
    public void setHash(String key, String hashKey, String value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }
}

第15课：集成 ActiveMQ

1. 依赖

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

2. 配置

spring:
  activemq:
    broker-url: tcp://localhost:61616
    user: admin
    password: admin

3. 点对点模式

// 配置队列
@Configuration
public class ActiveMQConfig {
    @Bean
    public Queue queue() {
        return new ActiveMQQueue("test.queue");
    }
}

// 生产者
@Service
public class Producer {
    @Autowired
    private JmsMessagingTemplate template;

    public void send(Queue queue, String msg) {
        template.convertAndSend(queue, msg);
    }
}

// 消费者
@Service
public class Consumer {
    @JmsListener(destination = "test.queue")
    public void receive(String msg) {
        System.out.println("收到消息：" + msg);
    }
}

第16课：集成 Shiro

1. 依赖

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.4.0</version>
</dependency>

2. 核心配置

@Configuration
public class ShiroConfig {
    // 自定义 Realm
    @Bean
    public MyRealm myRealm() {
        return new MyRealm();
    }

    // 安全管理器
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(myRealm());
        return manager;
    }

    // Shiro 过滤器
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean factory = new ShiroFilterFactoryBean();
        factory.setSecurityManager(securityManager);
        // 配置拦截规则
        Map<String, String> filterMap = new HashMap<>();
        filterMap.put("/login", "anon"); // 放行登录
        filterMap.put("/**", "authc"); // 其他需要认证
        factory.setFilterChainDefinitionMap(filterMap);
        return factory;
    }
}

3. 自定义 Realm

public class MyRealm extends AuthorizingRealm {
    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.addRole("admin"); // 添加角色
        info.addStringPermission("user:read"); // 添加权限
        return info;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String username = (String) token.getPrincipal();
        // 模拟从数据库查询密码
        if (!"admin".equals(username)) {
            throw new UnknownAccountException();
        }
        return new SimpleAuthenticationInfo(username, "123456", getName());
    }
}

第17课：集成 Lucene

1. 依赖

<dependency>
    <groupId>org.apache.lucene</groupId>
    <artifactId>lucene-core</artifactId>
    <version>5.3.1</version>
</dependency>
<dependency>
    <groupId>org.apache.lucene</groupId>
    <artifactId>lucene-analyzers-common</artifactId>
    <version>5.3.1</version>
</dependency>

2. 建立索引

public class Indexer {
    private IndexWriter writer;

    public Indexer(String indexDir) throws IOException {
        Directory dir = FSDirectory.open(Paths.get(indexDir));
        // 中文分词器
        Analyzer analyzer = new IKAnalyzer();
        writer = new IndexWriter(dir, new IndexWriterConfig(analyzer));
    }

    public void index(File file) throws IOException {
        Document doc = new Document();
        doc.add(new TextField("content", new FileReader(file)));
        writer.addDocument(doc);
    }
}

3. 搜索

public class Searcher {
    public void search(String indexDir, String queryStr) throws IOException {
        Directory dir = FSDirectory.open(Paths.get(indexDir));
        IndexReader reader = DirectoryReader.open(dir);
        IndexSearcher searcher = new IndexSearcher(reader);
        
        QueryParser parser = new QueryParser("content", new IKAnalyzer());
        Query query = parser.parse(queryStr);
        
        TopDocs docs = searcher.search(query, 10);
        for (ScoreDoc scoreDoc : docs.scoreDocs) {
            Document doc = searcher.doc(scoreDoc.doc);
            System.out.println(doc.get("content"));
        }
    }
}

第18课：项目架构搭建

核心架构组成

1. 统一返回结构：JsonResult<T>
2. 全局异常处理：GlobalExceptionHandler
3. 拦截器：登录验证、日志记录
4. 持久层：MyBatis 集成
5. API 文档：Swagger2
6. 配置管理：多环境配置

项目结构

com.itcodai
├── config        # 配置类
├── controller    # 控制器
├── dao           # 数据访问层
├── entity        # 实体类
├── exception     # 异常处理
├── service       # 业务逻辑层
│   └── impl      # 实现类
└── CourseApplication.java  # 启动类

常用注解整理

分类	注解名称	作用
核心注解	@SpringBootApplication	启动类注解，组合多个注解
	@Configuration	标识配置类
	@Bean	定义 Bean 实例
Web 注解	@RestController	控制器 + 响应 Json
	@RequestMapping	映射请求路径
	@GetMapping	GET 请求映射
	@PostMapping	POST 请求映射
依赖注入	@Autowired	自动注入
	@Resource	按名称注入
	@Component	标识组件
数据访问	@Mapper	MyBatis 映射接口
	@Select	查询注解
	@Insert	插入注解
事务	@Transactional	事务管理
AOP	@Aspect	切面类
	@Pointcut	切入点定义
配置绑定	@ConfigurationProperties	配置绑定到类
	@Value	注入配置值

常用 API 整理

1. SpringApplication.run()：启动 Spring Boot 应用
2. SpringContext.getBean()：获取 Bean 实例
3. RestTemplate：HTTP 客户端工具
4. JdbcTemplate：JDBC 操作工具
5. StringRedisTemplate：Redis 操作工具
6. JmsMessagingTemplate：消息队列操作工具

通过以上内容，可从零开始掌握 Spring Boot 开发，从基础配置到企业级组件集成，覆盖实际项目所需的核心技术点。建议结合示例代码动手实践，逐步构建完整项目架构。